G4QPDGCode Class Reference

#include <G4QPDGCode.hh>


Public Member Functions

 G4QPDGCode (G4int PDGCode=0)
 G4QPDGCode (G4bool f, G4int QCode)
 G4QPDGCode (G4QContent QCont)
 G4QPDGCode (const G4QPDGCode &rhs)
 G4QPDGCode (G4QPDGCode *rhs)
 ~G4QPDGCode ()
const G4QPDGCodeoperator= (const G4QPDGCode &rhs)
G4bool operator== (const G4QPDGCode &rhs) const
G4bool operator== (const G4int &rhs) const
G4bool operator!= (const G4QPDGCode &rhs) const
G4bool operator!= (const G4int &rhs) const
G4QPDGCode operator+= (const G4int &rhs)
G4QPDGCode operator+= (const G4QPDGCode &rhs)
G4QPDGCode operator-= (const G4int &rhs)
G4QPDGCode operator-= (const G4QPDGCode &rhs)
G4QPDGCode operator *= (const G4int &rhs)
G4QPDGCode operator/= (const G4int &rhs)
G4int GetNQHadr ()
G4double GetMass ()
G4double GetMass2 ()
G4double GetWidth ()
G4double GetNuclMass (G4int Z, G4int N, G4int S)
G4double GetNuclMass (G4int PDGCode)
G4QContent GetQuarkContent () const
G4int GetBaryNum () const
G4int GetSpin () const
G4int GetCharge () const
G4int GetPDGCode () const
G4int GetQCode () const
G4QContent GetExQContent (G4int i, G4int o) const
G4int GetRelCrossIndex (G4int i, G4int o) const
G4int GetNumOfComb (G4int i, G4int o) const
G4int GetTotNumOfComb (G4int i) const
void SetPDGCode (G4int newPDGCode)
void InitByQCont (G4QContent QCont)
void InitByQCode (G4int QCode)
G4bool TestRealNeutral ()
void NegPDGCode ()
void ConvertPDGToZNS (G4int PDG, G4int &z, G4int &n, G4int &s)
std::pair< G4int, G4intMakeTwoBaryons (G4int L1, G4int L2, G4int R1, G4int R2)


Detailed Description

Definition at line 141 of file G4QPDGCode.hh.


Constructor & Destructor Documentation

G4QPDGCode::G4QPDGCode ( G4int  PDGCode = 0  ) 

Definition at line 54 of file G4QPDGCode.cc.

References G4cout, and G4endl.

00054                                    : thePDGCode(PDGCode)
00055 {
00056 #ifdef sdebug
00057   G4cout<<"G4QPDGCode:Constructer is called with PDGCode="<<PDGCode<<G4endl;  
00058 #endif
00059   if(PDGCode==130) PDGCode= 311; // Safety. Should not happen.
00060   if(PDGCode==310) PDGCode=-311; // Safety. Should not happen.
00061   if(PDGCode==90000000)
00062   {
00063     thePDGCode=22;
00064     theQCode=6;
00065   }
00066   else if(PDGCode) theQCode=MakeQCode(PDGCode);
00067   else        
00068   {
00069 #ifdef sdebug
00070     G4cout<<"***G4QPDGCode: Constructed with PDGCode=0, QCode=-2"<<G4endl;  
00071 #endif
00072     theQCode=-2;
00073   }
00074 #ifdef debug
00075   if(PDGCode==3222)G4cout<<"G4QPDGCd:Con(PDG) PDG="<<PDGCode<<", QCode="<<theQCode<<G4endl;
00076 #endif
00077 }

G4QPDGCode::G4QPDGCode ( G4bool  f,
G4int  QCode 
)

Definition at line 79 of file G4QPDGCode.cc.

References G4cerr, G4cout, and G4endl.

00079                                            : theQCode(QCode)
00080 {
00081   if(f&&QCode<0)G4cerr<<"***G4QPDGCode::Constr. QCode="<<QCode<<G4endl;
00082   thePDGCode = MakePDGCode(QCode);
00083 #ifdef debug
00084   G4cout<<"G4QPDGCode::Constr: PDGCode="<<thePDGCode<<G4endl;
00085 #endif
00086 }

G4QPDGCode::G4QPDGCode ( G4QContent  QCont  ) 

Definition at line 88 of file G4QPDGCode.cc.

References InitByQCont().

00089 {
00090   InitByQCont(QCont);
00091 }

G4QPDGCode::G4QPDGCode ( const G4QPDGCode rhs  ) 

Definition at line 93 of file G4QPDGCode.cc.

References thePDGCode, and theQCode.

00094 {
00095   thePDGCode =rhs.thePDGCode;
00096   theQCode   =rhs.theQCode;
00097 }

G4QPDGCode::G4QPDGCode ( G4QPDGCode rhs  ) 

Definition at line 99 of file G4QPDGCode.cc.

References thePDGCode, and theQCode.

00100 {
00101   thePDGCode =rhs->thePDGCode;
00102   theQCode   =rhs->theQCode;
00103 }

G4QPDGCode::~G4QPDGCode (  ) 

Definition at line 115 of file G4QPDGCode.cc.

00115 {}


Member Function Documentation

void G4QPDGCode::ConvertPDGToZNS ( G4int  PDG,
G4int z,
G4int n,
G4int s 
)

Definition at line 2377 of file G4QPDGCode.cc.

Referenced by GetMass().

02378 {
02379   if(nucPDG>80000000&&nucPDG<100000000)            // Condition of conversion
02380   {
02381     z=0;
02382     n=0;
02383     s_value=0;
02384     G4int r=nucPDG;
02385     if(r==90000000) return;
02386     G4int cn =r%1000;                              // candidate to #of neutrons
02387     if(cn)
02388     {
02389       if(cn>500) cn-=1000;                         // AntiNeutrons
02390       n=cn;                                        // Increment neutrons
02391       r-=cn;                                       // Subtract them from the residual
02392       if(r==90000000) return;
02393     }
02394     G4int cz =r%1000000;                           // candidate to #of neutrons
02395     if(cz)
02396     {
02397       if(cz>500000) cz-=1000000;                   // AntiProtons
02398       z=cz/1000;                                   // Number of protons
02399       r-=cz;                                       // Subtract them from the residual
02400       if(r==90000000) return;
02401     }
02402     G4int cs =r%10000000;                           // candidate to #of neutrons
02403     if(cs)
02404     {
02405       if(cs>5000000) cs-=10000000;                 // AntiLambda
02406       s_value=cs/1000000;                          // Number of Lambdas
02407     }
02408   }
02409   return;
02410 }

G4int G4QPDGCode::GetBaryNum (  )  const [inline]

Definition at line 329 of file G4QPDGCode.hh.

References G4QContent::GetBaryonNumber(), and GetQuarkContent().

Referenced by G4QEnvironment::G4QEnvironment().

00329 {return GetQuarkContent().GetBaryonNumber();}

G4int G4QPDGCode::GetCharge (  )  const [inline]

Definition at line 328 of file G4QPDGCode.hh.

References G4QContent::GetCharge(), and GetQuarkContent().

Referenced by G4QEnvironment::G4QEnvironment().

00328 {return GetQuarkContent().GetCharge();}

G4QContent G4QPDGCode::GetExQContent ( G4int  i,
G4int  o 
) const

Definition at line 2244 of file G4QPDGCode.cc.

References G4cerr, G4QContent::IncAD(), G4QContent::IncAS(), G4QContent::IncAU(), G4QContent::IncD(), G4QContent::IncS(), and G4QContent::IncU().

02245 {
02246   G4QContent cQC(0,0,0,0,0,0);
02247   if     (!i)   cQC.IncAD();
02248   else if(i==1) cQC.IncAU();
02249   else if(i==2) cQC.IncAS();
02250   else G4cerr<<"***G4QPDGCode::GetExQContent: strange entering quark i="<<i<<G4endl;
02251   if     (!o)   cQC.IncD();
02252   else if(o==1) cQC.IncU();
02253   else if(o==2) cQC.IncS();
02254   else G4cerr<<"***G4QPDGCode::GetExQContent: strange exiting quark o="<<o<<G4endl;
02255   return cQC;
02256 }

G4double G4QPDGCode::GetMass (  ) 

Definition at line 693 of file G4QPDGCode.cc.

References ConvertPDGToZNS(), G4cout, and GetNuclMass().

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QIonIonCollision::Breeder(), G4QFragmentation::Breeder(), G4QEnvironment::CheckMassShell(), G4QEnvironment::DecayAntistrange(), G4QNucleus::EvaporateBaryon(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QIonIonCollision::Fragment(), G4QFragmentation::Fragment(), G4QCandidate::G4QCandidate(), G4QChipolino::G4QChipolino(), G4QDecayChan::G4QDecayChan(), G4QEnvironment::G4QEnvironment(), G4QHadron::G4QHadron(), G4QNucleus::GetGSMass(), G4QParticle::GetMass(), GetMass2(), G4QNucleus::InitByPDG(), G4QNGamma::PostStepDoIt(), G4QLowEnergy::PostStepDoIt(), G4QIonIonElastic::PostStepDoIt(), G4QInelastic::PostStepDoIt(), G4QElastic::PostStepDoIt(), G4QDiffraction::PostStepDoIt(), G4QCoherentChargeExchange::PostStepDoIt(), G4QAtomicElectronScattering::PostStepDoIt(), G4QNucleus::PrepareCandidates(), and G4QHadron::RandomizeMass().

00694 {
00695   G4int ab=theQCode;
00696 #ifdef pdebug
00697   G4bool pPrint = thePDGCode == 3222 || ab == 25;
00698   if(pPrint)
00699   G4cout<<"G4QPDGCode::GetMass: Mass for Q="<<ab<<",PDG="<<thePDGCode<<",N="<<nQHM<<G4endl;
00700 #endif
00701   if ( (ab < 0 && thePDGCode < 80000000) || !thePDGCode) {
00702 #ifdef pdebug
00703     if(thePDGCode!=10 && pPrint)
00704       G4cout<<"**G4QPDGCode::GetMass:m=100000.,QC="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
00705 #endif
00706     return 100000.;
00707   }
00708   else if(ab>-1 && ab<nQHM)
00709   {
00710     G4double mass = QHaM(ab);
00711 #ifdef pdebug
00712     //if(pPrint)
00713     if(thePDGCode == 3222 || ab == 25)
00714     G4cout<<"G4QPDGCode::GetMa:m="<<mass<<",Q="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
00715 #endif
00716     return mass;                                // Get mass from the table
00717   }
00718   //if(szn==0) return m[15];                    // @@ mPi0   @@ MK ?
00719   if(thePDGCode==90000000)
00720   {
00721 #ifdef pdebug
00722     if(pPrint)
00723     G4cout<<"G4QPDGCode::GetMass:***m=0, QC="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
00724 #endif
00725     return 0.;
00726   }
00727   G4int s_value=0;
00728   G4int z=0;
00729   G4int n=0;
00730   ConvertPDGToZNS(thePDGCode, z, n, s_value);
00731   G4double m_value=GetNuclMass(z,n,s_value);
00732 #ifdef pdebug
00733   if(pPrint)
00734   G4cout<<"G4QPDG::GetM:PDG="<<thePDGCode<<"=>Z="<<z<<",N="<<n<<",S="<<s_value<<",M="<<m_value<<G4endl;
00735 #endif
00736   return m_value;
00737 }

G4double G4QPDGCode::GetMass2 (  )  [inline]

Definition at line 281 of file G4QPDGCode.hh.

References GetMass().

00281 {G4double mass=GetMass(); return mass*mass;}

G4int G4QPDGCode::GetNQHadr (  )  [inline]

Definition at line 236 of file G4QPDGCode.hh.

00236 {return nQHM;} // Return # of predefined hadrons

G4double G4QPDGCode::GetNuclMass ( G4int  PDGCode  )  [inline]

Definition at line 282 of file G4QPDGCode.hh.

References GetNuclMass(), CLHEP::detail::n, and G4InuclParticleNames::nn.

00283 {
00284   if(PDG>80000000)
00285   {
00286     G4int szn=PDG-90000000;
00287     G4int ds=0;
00288     G4int dz=0;
00289     G4int dn=0;
00290     if(szn<-100000)
00291     {
00292       G4int ns_value=(-szn)/1000000+1;
00293       szn+=ns_value*1000000;
00294       ds+=ns_value;
00295     }
00296     else if(szn<-100)
00297     {
00298       G4int nz=(-szn)/1000+1;
00299       szn+=nz*1000;
00300       dz+=nz;
00301     }
00302     else if(szn<0)
00303     {
00304       G4int nn=-szn;
00305       szn=0;
00306       dn+=nn;
00307     }
00308     G4int sz =szn/1000;
00309     G4int n  =szn%1000;
00310     if(n>700)
00311     {
00312       n-=1000;
00313       dz--;
00314     }
00315     G4int z  =sz%1000-dz;
00316     if(z>700)
00317     {
00318       z-=1000;
00319       ds--;
00320     }
00321     G4int s_value  =sz/1000-ds;
00322     return GetNuclMass(z,n,s_value);
00323   }
00324   return 0.;
00325 }

G4double G4QPDGCode::GetNuclMass ( G4int  Z,
G4int  N,
G4int  S 
)

Definition at line 766 of file G4QPDGCode.cc.

References G4cout.

Referenced by G4QCaptureAtRest::AtRestDoIt(), G4QNucleus::G4QNucleus(), GetMass(), G4QNucleus::GetMZNS(), GetNuclMass(), G4QLowEnergy::PostStepDoIt(), and G4QInelastic::PostStepDoIt().

00767 {
00768   static const G4double anb = .01; // Antibinding for Ksi-n,Sig-n,Sig+p,Sig-nn,
00769   static const G4double mNeut= QHaM(20);
00770   static const G4double mProt= QHaM(21);
00771   static const G4double mLamb= QHaM(22);
00772   static const G4double mPiC = QHaM(15);
00773   static const G4double mKZ  = QHaM(17);
00774   static const G4double mKM  = QHaM(18);
00775   static const G4double mSiM = QHaM(23);
00776   static const G4double mSiP = QHaM(25);
00777   static const G4double mKsZ = QHaM(27);
00778   static const G4double mKsM = QHaM(26);
00779   static const G4double mOmM = QHaM(44);
00780   static const G4double mKZa = mKZ +anb;
00781   static const G4double mKMa = mKM +anb;
00782   static const G4double mSigM= mSiM+anb;
00783   static const G4double mSigP= mSiP+anb;
00784   static const G4double mKsiZ= mKsZ+anb;
00785   static const G4double mKsiM= mKsM+anb;
00786   static const G4double mOmeg= mOmM+anb;
00787   static const G4double mDiPi= mPiC+mPiC+anb;
00788   static const G4double mDiKZ= mKZa+mKZ;
00789   static const G4double mDiKM= mKMa+mKM;
00790   static const G4double mDiPr= mProt+mProt;
00791   static const G4double mDiNt= mNeut+mNeut;
00792   static const G4double mSmPi= mSiM+mDiPi;
00793   static const G4double mSpPi= mSiP+mDiPi;
00794   static const G4double mOmN = mOmeg+mNeut;
00795   static const G4double mSpP = mSigP+mProt;
00796   static const G4double mSpPP= mSpP +mProt;
00797   static const G4double mSmN = mSigM+mNeut;
00798   static const G4double mSmNN= mSmN +mNeut;
00799   // -------------- DAM Arrays ----------------------
00800   static const G4int iNR=76;    // Neutron maximum range for each Z
00801   static const G4int nEl = 105; // Maximum Z of the associative memory is "nEl-1=104"
00802   static const G4int iNF[nEl]={0,0,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, // 14
00803                          1  ,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, // 29
00804                          16 , 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, // 44
00805                          31 , 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 53, 54, 55, // 59
00806                          56 , 56, 57, 57, 58, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, // 74
00807                          71 , 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, // 89
00808                          86 , 87, 88, 89, 91, 94, 98,103,109,115,122,128,134,140,146};//104
00809 #ifdef qdebug
00810   static G4int iNmin[nEl]={0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, // 14
00811                          1  ,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, // 29
00812                          16 , 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, // 44
00813                          31 , 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 53, 54, 55, // 59
00814                          56 , 56, 57, 57, 58, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, // 74
00815                          71 , 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, // 89
00816                          86 , 87, 88, 89, 91, 94, 98,103,109,115,122,128,134,140,146};//104
00817   static G4int iNmax=iNR;
00818   static G4int iNran[nEl]={19,20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, // 14
00819                          34 , 35, 36, 37, 38, 39, 40, 48, 48, 48, 48, 50, 50, 50, 52, // 29
00820                          53 , 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, // 44
00821                          68 , 69, 70, 70, 70, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, // 59
00822                          73 , 73, 73, 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 76, // 74
00823                          76 , 76, 76, 76, 76, 75, 74, 73, 72, 71, 70, 70, 69, 69, 69, // 89
00824                          68 , 68, 68, 67, 63, 59, 55, 51, 47, 43, 39, 35, 31, 27, 23};//104
00825 #endif
00826   static const G4int iNL[nEl]={19,20,21,22,23,24, 25, 26, 27, 28, 29, 30, 31, 32, 33, // 14
00827                          34 , 35, 36, 37, 38, 39, 40, 48, 48, 48, 48, 50, 50, 50, 52, // 29
00828                          53 , 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, // 44
00829                          68 , 69, 70, 70, 70, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, // 59
00830                          73 , 73, 73, 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 76, // 74
00831                          76 , 76, 76, 76, 76, 75, 74, 73, 72, 71, 70, 70, 69, 69, 69, // 89
00832                          68 , 68, 68, 67, 63, 59, 55, 51, 47, 43, 39, 35, 31, 27, 23};//104
00833    // ********* S=-4 vectors *************
00834   static G4bool iNin6[nEl]={false,false,false,false,false,false,false,
00835     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00836     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00837     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00838     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00839     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00840     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00841     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00842   static G4double VZ6[nEl][iNR];
00843   //********* S=-3 vectors *************
00844   static G4bool iNin7[nEl]={false,false,false,false,false,false,false,
00845     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00846     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00847     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00848     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00849     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00850     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00851     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00852   static G4double VZ7[nEl][iNR];
00853   // ********* S=-2 vectors *************
00854   static G4bool iNin8[nEl]={false,false,false,false,false,false,false,
00855     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00856     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00857     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00858     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00859     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00860     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00861     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00862   static G4double VZ8[nEl][iNR];
00863   // ********* S=-1 vectors *************
00864   static G4bool iNin9[nEl]={false,false,false,false,false,false,false,
00865     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00866     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00867     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00868     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00869     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00870     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00871     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00872   static G4double VZ9[nEl][iNR];
00873   // ********* S=0 vectors *************
00874   static G4bool iNin0[nEl]={false,false,false,false,false,false,false,
00875     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00876     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00877     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00878     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00879     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00880     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00881     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00882  static G4double VZ0[nEl][iNR];
00883   // ********* S=1 vectors *************
00884   static G4bool iNin1[nEl]={false,false,false,false,false,false,false,
00885     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00886     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00887     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00888     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00889     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00890     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00891     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00892   static G4double VZ1[nEl][iNR];
00893   // ********* S=2 vectors *************
00894   static G4bool iNin2[nEl]={false,false,false,false,false,false,false,
00895     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00896     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00897     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00898     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00899     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00900     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00901     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00902   static G4double VZ2[nEl][iNR];
00903   // ********* S=3 vectors *************
00904   static G4bool iNin3[nEl]={false,false,false,false,false,false,false,
00905     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00906     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00907     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00908     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00909     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00910     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00911     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00912   static G4double VZ3[nEl][iNR];
00913   // ********* S=2 vectors *************
00914   static G4bool iNin4[nEl]={false,false,false,false,false,false,false,
00915     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00916     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00917     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00918     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00919     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00920     false,false,false,false,false,false,false,false,false,false,false,false,false,false,
00921     false,false,false,false,false,false,false,false,false,false,false,false,false,false};
00922   static G4double VZ4[nEl][iNR];
00923   //
00924 #ifdef qdebug
00925   static G4int Smin=-1; // Dynamic Associated memory is implemented for S>-2 nuclei
00926   static G4int Smax= 2; // Dynamic Associated memory is implemented for S< 3 nuclei
00927   static G4int NZmin= 0; // Dynamic Associated memory is implemented for Z>-1 nuclei
00928   static G4int NNmin= 0; // Dynamic Associated memory is implemented for N>-1 nuclei
00929   static G4int NZS1max= 0; // Dynamic Associated memory is implemented for S<3, Z=-1, N<2
00930   static G4int NNS1max= 0; // Dynamic Associated memory is implemented for S<3, Z=-1, N<2 
00931 #endif
00932   // -------------------------------------------------------------------------------------
00933   G4double rm=0.;
00934   G4int nz=n+z;
00935   G4int zns=nz+s_value;
00936   if(nz+s_value<0)
00937   {
00938     z=-z;
00939     n=-n;
00940     s_value=-s_value;
00941     nz=-nz;
00942     zns=-zns;
00943   }
00944   if(z<0)
00945   {
00946     if(z==-1)
00947     {
00948       if(!s_value)
00949       {
00950         if(n==1)      return mPiC;              // pi-
00951         else          return mPiC+(n-1)*mNeut;  // Delta- + (N-1)*n
00952       }
00953       else if(s_value==1)                       // Strange negative hadron
00954       {
00955         if(!n)        return mKM;               // K-
00956         else if(n==1) return mSiM;              // Sigma-
00957         else if(n==2) return mSmN ;             // Sigma- + n DiBaryon
00958         else if(n==3) return mSmNN;             // Sigma- +2n TriBaryon
00959         else          return mSigM+mNeut*(n-1); // Sigma- + (N-1)*n
00960       }
00961       else if(s_value==2)                       // --> Double-strange negative hadrons
00962       {
00963         if(!n)        return mKsM;              // Ksi-
00964         else if(n==1) return mKsiM+mNeut;       // Ksi- + n
00965         else if(n==2) return mKsiM+mNeut+mNeut; // Ksi- + 2n
00966         else          return mKsiM+mNeut*n;     // Ksi- + Z*n
00967       }
00968       else if(s_value==-2)
00969       {
00970         if     (nz==2)         return mDiKZ+mPiC; // 2K0 + Pi-
00971         else                   return mDiKZ+mPiC+(nz-2)*mProt;
00972       }
00973       else if(s_value==3)                       // --> Triple-strange negative hadrons
00974       {
00975         if     (n==-1) return mOmM;       // Triple-strange Omega minus
00976         else if(!n   ) return mOmN;       // Triple-strange (Omega-) + n DiBaryon
00977         else if(n==-2) return mDiKZ+mKM;  // Triple-strange K- + 2*K0
00978         else           return mOmeg+mNeut*(n+2);
00979       }
00980       else if(s_value==4)
00981       {
00982         if(n==-2)      return mOmeg+mKM;  // Omega- + K-
00983         else if(n==-1) return mOmeg+mLamb;// Omega- + Lambda
00984         else           return mOmeg+mLamb+(n+1)*mNeut; // Omega- + Lambda + (n+1)*Neutrons
00985       }
00986       else if(!n)            return mOmeg+(s_value-2)*mLamb; // Multy-Lambda + Omega minus
00987       else
00988       {
00989 #ifdef qdebug
00990         if(s_value>NZS1max)
00991         {
00992           NZS1max=s_value;
00993           G4cout<<"-------->>G4QPDGCode::GetNucMass: Z=-1, S="<<s_value<<">2 with N="<<n<<G4endl;
00994         }
00995 #endif
00996           return CalculateNuclMass(z,n,s_value);
00997       }
00998     }
00999     else if(!s_value)
01000     {
01001       if(!nz)
01002       {
01003         if(n==2)             return mDiPi;
01004         else                 return mDiPi+(n-2)*mPiC;
01005       }
01006       else                   return mNeut*nz-z*mPiC+anb;
01007     }
01008     else if(!zns)           // !!! s=0 is treated above !!
01009     {
01010       if(s_value>0)          return anb+s_value*mKM+n*mPiC; // s*K- + n*Pi-
01011       else                   return anb-s_value*mKZ-z*mPiC; // (-s)*aK0 + (-z)*Pi-
01012     }
01013     else if(s_value==1)
01014     {
01015       if(!nz)
01016       {
01017         if(n==2)             return mSmPi;
01018         else                 return mSmPi+(n-2)*mPiC;
01019       }
01020       else                   return mSigM+nz*mNeut-(z+1)*mPiC;
01021     }
01022     else if(s_value==-1)     return mKZa-z*mPiC+(nz-1)*mNeut; // aK0+(nz-1)n+(-z)*Pi-
01023     else if(s_value==2)
01024     {
01025       if     (nz==-1)        return mKsiM+n*mPiC;
01026       else if(!nz)           return mKsiM+mNeut-(z+1)*mPiC;
01027       else                   return mKsiM+(nz+1)*mNeut-(z+1)*mPiC;
01028     }
01029     else if(s_value==-2)     return mDiKZ-z*mPiC+(nz-2)*mNeut;
01030     else if(s_value==3)
01031     {
01032       if     (nz==-2)        return mOmeg+(n+1)*mPiC; // Omega- + (n+1)* Pi-
01033       else if(nz==-1)        return mOmeg+mNeut+n*mPiC; // Omega- + n * Pi-
01034       else if(!nz)           return mOmeg+mDiNt+(n-1)*mPiC; // Omega- + 2N + (n-1)*Pi-
01035       else                   return mOmeg+(nz+2)*mProt-(z+1)*mPiC;
01036     }
01037     else if(s_value<-2)      return anb-s_value*mKZ-z*mPiC+(nz+s_value)*mNeut;
01038     else if(s_value==4)
01039     {
01040       if     (nz==-3)        return mOmeg+mKM+(n+1)*mPiC;        // Om- + K- + (n+1)*Pi-
01041       else if(nz==-2)        return mOmeg+mSigM+n*mPiC;          // Om- + Sig- + n*Pi-
01042       else if(nz==-1)        return mOmeg+mSigM+mNeut+(n-1)*mPiC;//Om- + Sig- +N +(n-1)*Pi-
01043       else if(!nz)           return mOmeg+mSigM+mDiNt+(n-2)*mPiC;//Om- +Sig- +2N +(n-2)*Pi-
01044       else                   return mOmeg+mSigM+(nz+2)*mDiNt-(z+2)*mPiC;//+(nz+2)N-(z+2)Pi-
01045     }
01046     // s=5: 2*K-, Ksi-; s=6: 3*K-, Omega-; s>6 adds K- and Sigma- instead of Protons
01047     else                     // !!All s<0 are done and s>4 can be easy extended if appear!!
01048     {
01049 #ifdef qdebug
01050       if(z<NZmin)
01051       {
01052         NZmin=z;
01053         G4cout<<"---->>G4QPDGCode::GetNucMass: Z="<<z<<"<-1 with N="<<n<<", S="<<s_value<<G4endl;
01054       }
01055 #endif
01056       return CalculateNuclMass(z,n,s_value);
01057     }
01058   }
01059   else if(n<0)
01060   {
01061     if(n==-1)
01062     {
01063       if(!s_value)
01064       {
01065         if(z==1)      return mPiC;              // pi+
01066         else          return mPiC+(z-1)*mProt;  // Delta++ + (Z-1)*p
01067       }
01068       else if(s_value==1)                       // --> Strange neutral hadrons
01069       {
01070         if(!z)        return mKZ;               // K0
01071         else if(z==1) return mSiP;              // Sigma+
01072         else if(z==2) return mSpP ;             // Sigma+ + p DiBaryon
01073         else if(z==3) return mSpPP;             // Sigma+ +2p TriBaryon
01074         else          return mSigP+mProt*(z-1); // Sigma+ + (Z-1)*p
01075       }
01076       else if(s_value==2)                       // --> Double-strange negative hadrons
01077       {
01078         if(!z)        return mKsZ;              // Ksi0
01079         else if(z==1) return mKsiZ+mProt;       // Ksi- + p
01080         else if(z==2) return mKsiZ+mProt+mProt; // Ksi- + 2p
01081         else          return mKsiZ+mProt*z;     // Ksi- + Z*p
01082       }
01083       else if(s_value==-2)
01084       {
01085         if     (nz==2)         return mDiKM+mPiC; // 2K+ + Pi+
01086         else                   return mDiKM+mPiC+(nz-2)*mProt;
01087       }
01088       else if(s_value==3)
01089       {
01090         if(z==1) return mOmeg+mDiPr;
01091         else     return mOmeg+(z+1)*mProt;
01092       }
01093       else if(s_value==4) return mOmeg+mLamb+(z+1)*mProt;
01094       else if(!z) return mKZa+(s_value-1)*mLamb;      // Multy-Lambda + K0
01095       else
01096       {
01097 #ifdef qdebug
01098         if(s_value>NNS1max)
01099         {
01100           NNS1max=s_value;
01101           G4cout<<"-------->>G4QPDGCode::GetNucMass: N=-1, S="<<s_value<<">2 with Z="<<z<<G4endl;
01102         }
01103 #endif
01104           return CalculateNuclMass(z,n,s_value);
01105       }
01106     }
01107     else if(!s_value)
01108     {
01109       if(!nz)
01110       {
01111         if(z==2)             return mDiPi;
01112         else                 return mDiPi+(z-2)*mPiC;
01113       }
01114       else                   return mProt*nz-n*mPiC+anb;
01115     }
01116     else if(!zns)           // !!! s=0 is treated above !!
01117     {
01118       if(s_value>0)          return anb+s_value*mKZ+z*mPiC; // s*K0 + n*Pi+
01119       else                   return anb-s_value*mKM-n*mPiC; // (-s)*aK+ + (-n)*Pi+
01120     }
01121     else if(s_value==1)
01122     {
01123       if(!nz)
01124       {
01125         if(z==2)             return mSpPi;
01126         else                 return mSpPi+(z-2)*mPiC;
01127       }
01128       else                   return mSigP+nz*mProt-(n+1)*mPiC;
01129     }
01130     else if(s_value==-1)     return mKMa-n*mPiC+(nz-1)*mProt; // K+ + (nz-1)*P + (-n)*Pi+
01131     else if(s_value==2)
01132     {
01133       if     (nz==-1)        return mKsiZ+z*mPiC;
01134       else if(!nz)           return mKsiZ+mProt-(n+1)*mPiC;
01135       else                   return mKsiZ+(nz+1)*mProt-(n+1)*mPiC;
01136     }
01137     else if(s_value==-2)     return mDiKM-n*mPiC+(nz-2)*mProt;
01138     else if(s_value==3)
01139     {
01140       if     (nz==-2)        return mOmeg+(z+1)*mPiC;       // Omega + (z+1)*Pi+
01141       else if(nz==-1)        return mOmeg+mProt+z*mPiC;     // Omega- + P +z*Pi+
01142       else if(!nz)           return mOmeg+mDiPr+(z-1)*mPiC; // Omega- + 2P + (z-1)* Pi+
01143       else                   return mOmeg+(nz+2)*mProt-(n+1)*mPiC;
01144     }
01145     else if(s_value<-2)      return anb-s_value*mKM-n*mPiC+(nz+s_value)*mProt;
01146     else if(s_value==4)
01147     {
01148       if     (nz==-3)        return mOmeg+mKZ+(z+1)*mPiC;        // Om- + K0 + (z+1)*Pi+
01149       else if(nz==-2)        return mOmeg+mSigP+z*mPiC;          // Om- + Sig+ + z*Pi+
01150       else if(nz==-1)        return mOmeg+mSigP+mProt+(z-1)*mPiC;// Om- +Sig+ +P +(z-1)*Pi+
01151       else if(!nz)           return mOmeg+mSigP+mDiPr+(z-2)*mPiC;//Om- +Sig+ +2P +(z-2)*Pi+
01152       else                   return mOmeg+mSigP+(nz+2)*mProt-(n+2)*mPiC;//+(nz+2)P-(n+2)Pi+
01153     }
01154     // s=5: 2*KZ, Ksi0; s=6: 3*KZ, Omega-; s>6 adds K0 and Sigma+ instead of Protons
01155     else                     // !!All s<0 are done and s>4 can be easy extended if appear!!
01156     {
01157 #ifdef qdebug
01158       if(n<NNmin)
01159       {
01160         NNmin=n;
01161         G4cout<<"---->>G4QPDGCode::GetNucMass: N="<<n<<"<-1 with Z="<<z<<", S="<<s_value<<G4endl;
01162       }
01163 #endif
01164       return CalculateNuclMass(z,n,s_value);
01165     }
01166   }
01167   //return CalculateNuclMass(z,n,s_value); // @@ This is just to compare the calculation time @@
01168   if(nz >= 256 || z >= nEl) return 256000.;
01169   if(!s_value)             // **************> S=0 nucleus
01170   {
01171     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01172     if(!iNin0[z])          // =--=> This element is already initialized
01173     {
01174 #ifdef idebug
01175       G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=0 is initialized. F="<<iNin0[z]<<G4endl;
01176 #endif
01177       G4int iNfin=iNL[z];
01178       if(iNfin>iNR) iNfin=iNR;
01179       for (G4int in=0; in<iNfin; in++) VZ0[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01180       iNin0[z]=true;
01181     }
01182     G4int dNn=n-Nmin;
01183     if(dNn<0)              // --> The minimum N must be reduced 
01184     {
01185 #ifdef qdebug
01186       if(n<iNmin[z])
01187       {
01188         G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=0 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01189         iNmin[z]=n;
01190       }
01191 #endif
01192       return CalculateNuclMass(z,n,s_value);
01193     }
01194     else if(dNn<iNL[z]) return VZ0[z][dNn]; // Found in DAM
01195     else                   // --> The maximum N must be increased
01196     {
01197 #ifdef qdebug
01198       if(dNn>iNmax)
01199       {
01200         G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=0 with dN="<<dNn<<">"<<iNmax<<G4endl;
01201         iNmax=dNn;
01202       }
01203       if(dNn>iNran[z])
01204       {
01205         G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=0 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01206         iNran[z]=dNn;
01207       }
01208 #endif
01209       return CalculateNuclMass(z,n,s_value);
01210     }
01211   }
01212   else if(s_value==1)      // ******************> S=1 nucleus
01213   {
01214     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01215 #ifdef pdebug
01216     G4bool pPrint = !z && !n;
01217     if(pPrint)
01218       G4cout<<"G4QPDGC::GetNucM:Nmin="<<Nmin<<",iNin1="<<iNin1[0]<<",iNL="<<iNL[0]<<G4endl;
01219 #endif
01220     if(!iNin1[z])          // =--=> This element is already initialized
01221     {
01222 #ifdef pdebug
01223       if(pPrint)
01224       G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=1 is initialized. F="<<iNin1[z]<<G4endl;
01225 #endif
01226       G4int iNfin=iNL[z];
01227       if(iNfin>iNR) iNfin=iNR;
01228       for (G4int in=0; in<iNfin; in++) VZ1[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01229       iNin1[z]=true;
01230     }
01231     G4int dNn=n-Nmin;
01232     if(dNn<0)              // --> The minimum N must be reduced 
01233     {
01234 #ifdef qdebug
01235       if(n<iNmin[z])
01236       {
01237         G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=1 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01238         iNmin[z]=n;
01239       }
01240 #endif
01241       return CalculateNuclMass(z,n,s_value);
01242     }
01243     else if(dNn<iNL[z]) return VZ1[z][dNn]; // Found in DAM
01244     else                   // --> The maximum N must be increased
01245     {
01246 #ifdef qdebug
01247       if(dNn>iNmax)
01248       {
01249         G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=1 with dN="<<dNn<<">"<<iNmax<<G4endl;
01250         iNmax=dNn;
01251       }
01252       if(dNn>iNran[z])
01253       {
01254         G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=1 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01255         iNran[z]=dNn;
01256       }
01257 #endif
01258       return CalculateNuclMass(z,n,s_value);
01259     }
01260   }
01261   else if(s_value==-1)     // ******************> S=-1 nucleus
01262   {
01263     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01264     if(!iNin9[z])          // =--=> This element is already initialized
01265     {
01266 #ifdef idebug
01267       G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-1 is initialized. F="<<iNin9[z]<<G4endl;
01268 #endif
01269       G4int iNfin=iNL[z];
01270       if(iNfin>iNR) iNfin=iNR;
01271       for (G4int in=0; in<iNfin; in++) VZ9[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01272       iNin9[z]=true;
01273     }
01274     G4int dNn=n-Nmin;
01275     if(dNn<0)              // --> The minimum N must be reduced 
01276     {
01277 #ifdef qdebug
01278       if(n<iNmin[z])
01279       {
01280         G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<" ,S=-1 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01281         iNmin[z]=n;
01282       }
01283 #endif
01284       return CalculateNuclMass(z,n,s_value);
01285     }
01286     else if(dNn<iNL[z]) return VZ9[z][dNn]; // Found in DAM
01287     else                   // --> The maximum N must be increased
01288     {
01289 #ifdef qdebug
01290       if(dNn>iNmax)
01291       {
01292         G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-1 with dN="<<dNn<<">"<<iNmax<<G4endl;
01293         iNmax=dNn;
01294       }
01295       if(dNn>iNran[z])
01296       {
01297         G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-1 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01298         iNran[z]=dNn;
01299       }
01300 #endif
01301       return CalculateNuclMass(z,n,s_value);
01302     }
01303   }
01304   else if(s_value==2)      // ******************> S=2 nucleus
01305   {
01306     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01307     if(!iNin2[z])          // =--=> This element is already initialized
01308     {
01309 #ifdef idebug
01310       G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=2 is initialized. F="<<iNin2[z]<<G4endl;
01311 #endif
01312       G4int iNfin=iNL[z];
01313       if(iNfin>iNR) iNfin=iNR;
01314       for (G4int in=0; in<iNfin; in++) VZ2[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01315       iNin2[z]=true;
01316     }
01317     G4int dNn=n-Nmin;
01318     if(dNn<0)              // --> The minimum N must be reduced 
01319     {
01320 #ifdef qdebug
01321       if(n<iNmin[z])
01322       {
01323         G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=2 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01324         iNmin[z]=n;
01325       }
01326 #endif
01327       return CalculateNuclMass(z,n,s_value);
01328     }
01329     else if(dNn<iNL[z]) return VZ2[z][dNn]; // Found in DAM
01330     else                   // --> The maximum N must be increased
01331     {
01332 #ifdef qdebug
01333       if(dNn>iNmax)
01334       {
01335         G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=2 with dN="<<dNn<<">"<<iNmax<<G4endl;
01336         iNmax=dNn;
01337       }
01338       if(dNn>iNran[z])
01339       {
01340         G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=2 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01341         iNran[z]=dNn;
01342       }
01343 #endif
01344       return CalculateNuclMass(z,n,s_value);
01345     }
01346   }
01347   else if(s_value==-2)     // ******************> S=-2 nucleus
01348   {
01349     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01350     if(!iNin8[z])          // =--=> This element is already initialized
01351     {
01352 #ifdef idebug
01353       G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 is initialized. F="<<iNin8[z]<<G4endl;
01354 #endif
01355       G4int iNfin=iNL[z];
01356       if(iNfin>iNR) iNfin=iNR;
01357       for (G4int in=0; in<iNfin; in++) VZ8[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01358       iNin8[z]=true;
01359     }
01360     G4int dNn=n-Nmin;
01361     if(dNn<0)              // --> The minimum N must be reduced 
01362     {
01363 #ifdef qdebug
01364       if(n<iNmin[z])
01365       {
01366         G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01367         iNmin[z]=n;
01368       }
01369 #endif
01370       return CalculateNuclMass(z,n,s_value);
01371     }
01372     else if(dNn<iNL[z]) return VZ8[z][dNn]; // Found in DAM
01373     else                   // --> The maximum N must be increased
01374     {
01375 #ifdef qdebug
01376       if(dNn>iNmax)
01377       {
01378         G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with dN="<<dNn<<">"<<iNmax<<G4endl;
01379         iNmax=dNn;
01380       }
01381       if(dNn>iNran[z])
01382       {
01383         G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01384         iNran[z]=dNn;
01385       }
01386 #endif
01387       return CalculateNuclMass(z,n,s_value);
01388     }
01389   }
01390   else if(s_value==-3)     // ******************> S=-3 nucleus
01391   {
01392     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01393     if(!iNin7[z])          // =--=> This element is already initialized
01394     {
01395 #ifdef idebug
01396       G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 is initialized. F="<<iNin7[z]<<G4endl;
01397 #endif
01398       G4int iNfin=iNL[z];
01399       if(iNfin>iNR) iNfin=iNR;
01400       for (G4int in=0; in<iNfin; in++) VZ7[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01401       iNin7[z]=true;
01402     }
01403     G4int dNn=n-Nmin;
01404     if(dNn<0)              // --> The minimum N must be reduced 
01405     {
01406 #ifdef qdebug
01407       if(n<iNmin[z])
01408       {
01409         G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01410         iNmin[z]=n;
01411       }
01412 #endif
01413       return CalculateNuclMass(z,n,s_value);
01414     }
01415     else if(dNn<iNL[z]) return VZ7[z][dNn]; // Found in DAM
01416     else                   // --> The maximum N must be increased
01417     {
01418 #ifdef qdebug
01419       if(dNn>iNmax)
01420       {
01421         G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with dN="<<dNn<<">"<<iNmax<<G4endl;
01422         iNmax=dNn;
01423       }
01424       if(dNn>iNran[z])
01425       {
01426         G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01427         iNran[z]=dNn;
01428       }
01429 #endif
01430       return CalculateNuclMass(z,n,s_value);
01431     }
01432   }
01433   else if(s_value==3)      // ******************> S=3 nucleus
01434   {
01435     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01436     if(!iNin3[z])          // =--=> This element is already initialized
01437     {
01438 #ifdef idebug
01439       G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=3 is initialized. F="<<iNin3[z]<<G4endl;
01440 #endif
01441       G4int iNfin=iNL[z];
01442       if(iNfin>iNR) iNfin=iNR;
01443       for (G4int in=0; in<iNfin; in++) VZ3[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01444       iNin3[z]=true;
01445     }
01446     G4int dNn=n-Nmin;
01447     if(dNn<0)              // --> The minimum N must be reduced 
01448     {
01449 #ifdef qdebug
01450       if(n<iNmin[z])
01451       {
01452         G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=3 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01453         iNmin[z]=n;
01454       }
01455 #endif
01456       return CalculateNuclMass(z,n,s_value);
01457     }
01458     else if(dNn<iNL[z]) return VZ3[z][dNn]; // Found in DAM
01459     else                   // --> The maximum N must be increased
01460     {
01461 #ifdef qdebug
01462       if(dNn>iNmax)
01463       {
01464         G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=3 with dN="<<dNn<<">"<<iNmax<<G4endl;
01465         iNmax=dNn;
01466       }
01467       if(dNn>iNran[z])
01468       {
01469         G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=3 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01470         iNran[z]=dNn;
01471       }
01472 #endif
01473       return CalculateNuclMass(z,n,s_value);
01474     }
01475   }
01476   else if(s_value==-4)     // ******************> S=-4 nucleus
01477   {
01478     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01479     if(!iNin6[z])          // =--=> This element is already initialized
01480     {
01481 #ifdef idebug
01482       G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 is initialized. F="<<iNin6[z]<<G4endl;
01483 #endif
01484       G4int iNfin=iNL[z];
01485       if(iNfin>iNR) iNfin=iNR;
01486       for (G4int in=0; in<iNfin; in++) VZ6[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01487       iNin6[z]=true;
01488     }
01489     G4int dNn=n-Nmin;
01490     if(dNn<0)              // --> The minimum N must be reduced 
01491     {
01492 #ifdef qdebug
01493       if(n<iNmin[z])
01494       {
01495         G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01496         iNmin[z]=n;
01497       }
01498 #endif
01499       return CalculateNuclMass(z,n,s_value);
01500     }
01501     else if(dNn<iNL[z]) return VZ6[z][dNn]; // Found in DAM
01502     else                   // --> The maximum N must be increased
01503     {
01504 #ifdef qdebug
01505       if(dNn>iNmax)
01506       {
01507         G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with dN="<<dNn<<">"<<iNmax<<G4endl;
01508         iNmax=dNn;
01509       }
01510       if(dNn>iNran[z])
01511       {
01512         G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01513         iNran[z]=dNn;
01514       }
01515 #endif
01516       return CalculateNuclMass(z,n,s_value);
01517     }
01518   }
01519   else if(s_value==4)      // ******************> S=4 nucleus
01520   {
01521     G4int Nmin=iNF[z];     // Minimun N(Z) for the Dynamic Associative Memory (DAM)
01522     if(!iNin4[z])          // =--=> This element is already initialized
01523     {
01524 #ifdef idebug
01525       G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=4 is initialized. F="<<iNin4[z]<<G4endl;
01526 #endif
01527       G4int iNfin=iNL[z];
01528       if(iNfin>iNR) iNfin=iNR;
01529       for (G4int in=0; in<iNfin; in++) VZ4[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
01530       iNin4[z]=true;
01531     }
01532     G4int dNn=n-Nmin;
01533     if(dNn<0)              // --> The minimum N must be reduced 
01534     {
01535 #ifdef qdebug
01536       if(n<iNmin[z])
01537       {
01538         G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=4 with N="<<n<<"<"<<iNmin[z]<<G4endl;
01539         iNmin[z]=n;
01540       }
01541 #endif
01542       return CalculateNuclMass(z,n,s_value);
01543     }
01544     else if(dNn<iNL[z]) return VZ4[z][dNn]; // Found in DAM
01545     else                   // --> The maximum N must be increased
01546     {
01547 #ifdef qdebug
01548       if(dNn>iNmax)
01549       {
01550         G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=4 with dN="<<dNn<<">"<<iNmax<<G4endl;
01551         iNmax=dNn;
01552       }
01553       if(dNn>iNran[z])
01554       {
01555         G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=4 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
01556         iNran[z]=dNn;
01557       }
01558 #endif
01559       return CalculateNuclMass(z,n,s_value);
01560     }
01561   }
01562   else
01563   {
01564 #ifdef qdebug
01565     if(s_value<Smin || s_value>Smax)
01566     {
01567       if(s_value<Smin) Smin=s_value;
01568       if(s_value>Smax) Smax=s_value;
01569       G4cout<<">>G4QPDGCode::GetNucM:Z="<<z<<" with S="<<s_value<<",N="<<n<<" (Improve)"<<G4endl;
01570     }
01571 #endif
01572     rm=CalculateNuclMass(z,n,s_value);
01573   }
01574 #ifdef debug
01575   G4cout<<"G4QPDGCode::GetMass:GetNuclMass="<<rm<<",Z="<<z<<",N="<<n<<",S="<<s_value<<G4endl;
01576 #endif
01577   return rm;
01578 } // End of GetNuclearMass

G4int G4QPDGCode::GetNumOfComb ( G4int  i,
G4int  o 
) const

Definition at line 2347 of file G4QPDGCode.cc.

References G4cerr, G4QContent::GetD(), GetQuarkContent(), GetRelCrossIndex(), G4QContent::GetS(), G4QContent::GetU(), and InitByQCode().

Referenced by GetTotNumOfComb().

02348 {
02349   if(i>-1&&i<3)
02350   {
02351     G4int shiftQ=GetRelCrossIndex(i, o);
02352     G4int sQCode=theQCode;                     // QCode of the parent cluster
02353     if     (shiftQ==7) return 0;               // A parent cluster doesn't exist
02354     else if(!shiftQ) sQCode+=shiftQ;           // Shift QCode of son to QCode of his parent
02355     G4QPDGCode parent;                         // Create a temporary (fake) parent cluster
02356     parent.InitByQCode(sQCode);                // Initialize it by Q-Code
02357     G4QContent parentQC=parent.GetQuarkContent();// Quark Content of the parent cluster
02358     if     (!o)   return parentQC.GetD();
02359     else if(o==1) return parentQC.GetU();
02360     else if(o==2) return parentQC.GetS();
02361     else G4cerr<<"***G4QPDGCode:::GetNumOfComb: strange exiting quark o="<<o<<G4endl;
02362   }
02363   else G4cerr<<"***G4QPDGCode:::GetNumOfComb: strange entering quark i="<<i<<G4endl;
02364   return 0;
02365 }

G4int G4QPDGCode::GetPDGCode (  )  const [inline]

Definition at line 326 of file G4QPDGCode.hh.

Referenced by G4QIonIonCollision::Breeder(), G4QFragmentation::Breeder(), G4Quasmon::DecayQHadron(), G4QNucleus::EvaporateNucleus(), G4QFragmentation::EvaporateResidual(), G4QFragmentation::Fragment(), G4QChipolino::G4QChipolino(), G4QEnvironment::G4QEnvironment(), G4QHadron::G4QHadron(), G4QParticle::G4QParticle(), G4QParticle::GetPDGCode(), G4QHadron::GetPDGCode(), G4QNucleus::InitCandidateVector(), operator *(), operator%(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator<<(), G4QHadron::RandomizeMass(), and G4QHadron::SetQPDG().

00326 {return thePDGCode;}

G4int G4QPDGCode::GetQCode (  )  const [inline]

Definition at line 327 of file G4QPDGCode.hh.

Referenced by G4QEnvironment::G4QEnvironment(), G4QHadron::G4QHadron(), G4QParticle::G4QParticle(), G4QParticle::GetQCode(), G4QHadron::GetQCode(), G4QCHIPSWorld::GetQParticle(), G4QParticle::InitPDGParticle(), operator<<(), and G4QHadron::SetQPDG().

00327 {return theQCode;}

G4QContent G4QPDGCode::GetQuarkContent (  )  const

Definition at line 2057 of file G4QPDGCode.cc.

References G4cerr, G4cout, and G4InuclParticleNames::nn.

Referenced by G4QCandidate::G4QCandidate(), G4QChipolino::G4QChipolino(), G4QEnvironment::G4QEnvironment(), G4QHadron::G4QHadron(), G4QParticle::G4QParticle(), GetBaryNum(), GetCharge(), GetNumOfComb(), GetSpin(), G4QNucleus::InitCandidateVector(), G4QParticle::InitPDGParticle(), G4QParticle::InitQParticle(), G4QChipolino::SetHadronQPDG(), and G4QHadron::SetQPDG().

02058 {
02059   G4int            a=0; // particle
02060   if(thePDGCode<0) a=1; // anti-particle
02061   G4int d=0;
02062   G4int u=0;
02063   G4int s_value=0;
02064   G4int ad=0;
02065   G4int au=0;
02066   G4int as=0;
02067   G4int ab=abs(thePDGCode);
02068   if     (!ab)
02069   {
02070     G4cerr<<"***G4QPDGCode::GetQuarkContent: PDG=0, return (0,0,0,0,0,0)"<<G4endl;
02071     return G4QContent(0,0,0,0,0,0);
02072   }
02073   else if(ab<4) // @@ for SU(6) : ab<7
02074   {
02075     if     (thePDGCode== 1) return G4QContent(1,0,0,0,0,0);
02076     else if(thePDGCode== 2) return G4QContent(0,1,0,0,0,0);
02077     else if(thePDGCode== 3) return G4QContent(0,0,1,0,0,0);
02078     else if(thePDGCode==-1) return G4QContent(0,0,0,1,0,0);
02079     else if(thePDGCode==-2) return G4QContent(0,0,0,0,1,0);
02080     else if(thePDGCode==-3) return G4QContent(0,0,0,0,0,1);
02081   }
02082   else if(ab<99)
02083   {
02084     if     (thePDGCode== 11) return G4QContent(1,0,0,0,1,0);
02085     else if(thePDGCode==-11) return G4QContent(0,1,0,1,0,0);
02086     else if(thePDGCode== 13) return G4QContent(1,0,0,0,1,0);
02087     else if(thePDGCode==-13) return G4QContent(0,1,0,1,0,0);
02088     else if(thePDGCode== 15) return G4QContent(1,0,0,0,1,0);
02089     else if(thePDGCode==-15) return G4QContent(0,1,0,1,0,0);
02090 #ifdef debug
02091     if     (ab==22) G4cout<<"-W-G4QPDGC::GetQuarkCont: For the Photon? - Return 0"<<G4endl;
02092     else if(ab==10) G4cout<<"-W-G4QPDGC::GetQuarkCont: For Chipolino? - Return 0"<<G4endl;
02093     else G4cout<<"-W-G4QPDGCode::GetQuarkCont: For PDG="<<thePDGCode<<" Return 0"<<G4endl;
02094 #endif
02095     return G4QContent(0,0,0,0,0,0); // Photon, bosons, leptons
02096   }
02097   else if(ab<80000000) // Baryons & Mesons
02098   {
02099     G4int c=ab/10;     // temporary (quarks)
02100     G4int f=c%10;      // (1) low quark
02101     G4int v=c/10;      // (2,3) temporary(B) or (2) final(M) (high quarks, high quark)
02102     G4int t=0;         // (3)prototype of highest quark (B)
02103 #ifdef sdebug
02104     G4cout<<"G4QPDGCode::GetQuarkContent: a="<<ab<<", c="<<c<<", f="<<f<<", v="<<v<<G4endl;
02105 #endif
02106     if(v>10)           // Baryons
02107     {
02108       t=v/10;          // (3) highest quark
02109       v%=10;           // (2) high quark
02110       if     (f==1)
02111       {
02112         if(a) ad++;
02113         else   d++;
02114       }
02115       else if(f==2)
02116       {
02117         if(a) au++;
02118         else   u++;
02119       }
02120       else if(f==3)
02121       {
02122         if(a) as++;
02123         else   s_value++;
02124       }
02125       else G4cerr<<"*G4QPDGC::GetQCont:1 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
02126       if     (v==1)
02127       {
02128         if(a) ad++;
02129         else   d++;
02130       }
02131       else if(v==2)
02132       {
02133         if(a) au++;
02134         else   u++;
02135       }
02136       else if(v==3)
02137       {
02138         if(a) as++;
02139         else   s_value++;
02140       }
02141       else G4cerr<<"*G4QPDGC::GetQCont:2 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
02142       if     (t==1)
02143       {
02144         if(a) ad++;
02145         else   d++;
02146       }
02147       else if(t==2)
02148       {
02149         if(a) au++;
02150         else   u++;
02151       }
02152       else if(t==3)
02153       {
02154         if(a) as++;
02155         else   s_value++;
02156       }
02157       else G4cerr<<"*G4QPDGC::GetQCont:3 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
02158       return G4QContent(d,u,s_value,ad,au,as);
02159     }
02160     else        // Mesons
02161     {
02162       if(f==v)
02163       {
02164         if     (f==1) return G4QContent(1,0,0,1,0,0);
02165         else if(f==2) return G4QContent(0,1,0,0,1,0);
02166         else if(f==3) return G4QContent(0,0,1,0,0,1);
02167         else G4cerr<<"*G4QPDGC::GetQC:4 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
02168       }
02169       else
02170       {
02171         if     (f==1 && v==2)
02172         {
02173           if(a)return G4QContent(1,0,0,0,1,0);
02174           else return G4QContent(0,1,0,1,0,0);
02175         }
02176         else if(f==1 && v==3)
02177         {
02178           if(a)return G4QContent(0,0,1,1,0,0);
02179           else return G4QContent(1,0,0,0,0,1);
02180         }
02181         else if(f==2 && v==3)
02182         {
02183           if(a)return G4QContent(0,0,1,0,1,0);
02184           else return G4QContent(0,1,0,0,0,1);
02185         }
02186         else G4cerr<<"*G4QPDGC::GetQC:5 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
02187       }
02188     }
02189   }
02190   else                    
02191   {
02192     G4int szn=ab-90000000;
02193     G4int ds=0;
02194     G4int dz=0;
02195     G4int dn=0;
02196     if(szn<-100000)
02197     {
02198       G4int ns_value=(-szn)/1000000+1;
02199       szn+=ns_value*1000000;
02200       ds+=ns_value;
02201     }
02202     else if(szn<-100)
02203     {
02204       G4int nz=(-szn)/1000+1;
02205       szn+=nz*1000;
02206       dz+=nz;
02207     }
02208     else if(szn<0)
02209     {
02210       G4int nn=-szn;
02211       szn=0;
02212       dn+=nn;
02213     }
02214     G4int sz =szn/1000;
02215     G4int n  =szn%1000;
02216     if(n>700)
02217     {
02218       n-=1000;
02219       dz--;
02220     }
02221     G4int z  =sz%1000-dz;
02222     if(z>700)
02223     {
02224       z-=1000;
02225       ds--;
02226     }
02227     s_value  =sz/1000-ds;
02228     G4int b=z+n+s_value;
02229     d=n+b;
02230     u=z+b;
02231     if      (d<0&&u<0&&s_value<0) return G4QContent(0,0,0,-d,-u,-s_value);
02232     else if (u<0&&s_value<0)      return G4QContent(d,0,0,0,-u,-s_value);
02233     else if (d<0&&s_value<0)      return G4QContent(0,u,0,-d,0,-s_value);
02234     else if (d<0&&u<0)            return G4QContent(0,0,s_value,-d,-u,0);
02235     else if (u<0)                 return G4QContent(d,0,s_value,0,-u,0);
02236     else if (s_value<0)           return G4QContent(d,u,0,0,0,-s_value);
02237     else if (d<0)                 return G4QContent(0,u,s_value,-d,0,0);
02238     else                          return G4QContent(d,u,s_value,0,0,0);
02239   }
02240   return G4QContent(0,0,0,0,0,0);
02241 }

G4int G4QPDGCode::GetRelCrossIndex ( G4int  i,
G4int  o 
) const

Definition at line 2259 of file G4QPDGCode.cc.

References G4cout.

Referenced by GetNumOfComb().

02260 {
02261   //                          pD,nD,DD,DD,ppDnnDpDDnDD n, p, L,S-,S+,X-,X0,O-
02262   static const G4int b01[16]={ 7,15, 7, 7, 7, 7, 7, 7, 1, 7, 7,-1, 7, 7, 7, 7};
02263   static const G4int b02[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7, 7, 7, 7, 7};
02264   static const G4int b10[16]={18, 7, 7, 7, 7, 7, 7, 7, 7,-1, 7, 7,-2, 7, 7, 7}; // Iso+Bary
02265   static const G4int b12[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 1, 7, 7, 7, 7, 7, 7};
02266   static const G4int b20[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,-2, 7,-3, 7,-4, 7};
02267   static const G4int b21[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,-1,-3, 7,-3, 7, 7};
02268   //                          nn,np,pp,Ln,Lp,LL,nS,pS,nnpnppLnnLpnLppLLnLLpnnS
02269   static const G4int d01[16]={ 1, 1, 7, 1, 7, 7,-3, 7, 1, 7, 1, 1, 7, 1, 7,-5};
02270   static const G4int d02[16]={ 3, 3, 7, 2, 7, 7, 7, 7, 3, 3, 3, 3, 7, 7, 7, 7};
02271   static const G4int d10[16]={ 7,-1,-1, 7,-1, 7, 7,-4, 7,-1, 7,-1,-1, 7,-1, 7}; //B=2,3
02272   static const G4int d12[16]={ 7, 2, 2, 7, 1, 7, 7, 7, 2, 2, 7, 2, 2, 7, 7, 7};
02273   static const G4int d20[16]={ 7, 7, 7,-3,-3,-2, 7,-5, 7, 7, 7,-3,-3,-3,-3, 7};
02274   static const G4int d21[16]={ 7, 7, 7,-2,-2,-1,-6, 7, 7, 7,-2,-2, 7,-2,-2, 7};
02275   //                          nn,np,pp,Ln,Lp,nn,np,pp! n, p,nn,np,pp,Ln,Lp
02276   static const G4int m01[15]={ 1, 1, 7, 1, 7, 1, 1, 7, 1, 7, 1, 1, 7, 1, 7};// Multibaryons
02277   static const G4int m02[15]={ 3, 3, 7, 3, 3, 7, 7, 7, 3, 3, 3, 3, 7, 7, 7};// @@ Regular !
02278   static const G4int m10[15]={ 7,-1,-1, 7,-1, 7,-1,-1, 7,-1, 7,-1,-1, 7,-1};// 01->1,10->-1
02279   static const G4int m12[15]={ 7, 2, 2, 2, 2, 7, 7, 7, 2, 2, 7, 2, 2, 7, 7};// 12->2,21->-2
02280   static const G4int m20[15]={ 7, 7, 7,-3,-3, 7,-3,-3, 7, 7, 7,-3,-3,-3,-3};// 02->3,20->-3
02281   static const G4int m21[15]={ 7, 7, 7,-2,-2,-2,-2, 7, 7, 7,-2,-2, 7,-2,-2};
02282   //static const G4int fragmStart = 82;    // "Isonuclei are added & Leptons are added"
02283   static const G4int fragmStart = 45;    // "Isonuclei & Leptons are added, Reduced"
02284 
02285   if(theQCode<fragmStart) return 7;
02286   G4int sub=theQCode-fragmStart;
02287   if ( (sub > 1 && sub < 8) || (sub > 12 && sub <16)) return 7; // SuperIso & SuperStrange 
02288   G4int rel=sub;                         // case of nuclear baryons and isonuclei
02289   if     (sub>31) rel =(sub-32)%15;      // case of heavy fragments (BaryNum>3)
02290   else if(sub>15) rel = sub-16;          // case of nuclear di-baryon & tri-baryons
02291 #ifdef debug
02292   G4cout<<"G4QPDGCode::RelGetCrossIndex:i="<<i<<",o="<<o<<",su="<<sub<<",re="<<rel<<G4endl;
02293 #endif
02294   //if ( (rel > 5 && rel < 9) || (rel > 13 && rel <16)) return 7; // SuperStrange're closed
02295   if     (!i)                            // ==> input quark = 0(d) (d=-1/3)
02296   {
02297     if     (!o)       return 0;          // -> output quark = 0(d) => 0 = the same cluster
02298     else if(o==1)                        // -> output quark = 1(u) (ch--)
02299     {
02300       if     (sub<16) return b01[rel];
02301       else if(sub<32) return d01[rel];
02302       else            return m01[rel];
02303     }
02304     else if(o==2)
02305     {
02306       if     (sub<16) return b02[rel];
02307       else if(sub<32) return d02[rel];
02308       else            return m02[rel];
02309     }
02310   }
02311   else if(i==1)                          // ==> input quark = 1(u) (u=2/3)
02312   {
02313     if     (!o)                          // -> output quark = 0(d) (ch++)
02314     {
02315       if     (sub<16) return b10[rel];
02316       else if(sub<32) return d10[rel];
02317       else            return m10[rel];
02318     }
02319     else if(o==1)     return 0;         // -> output quark = 1(u) => 0 = the same cluster
02320     else if(o==2)
02321     {
02322       if     (sub<16) return b12[rel];
02323       else if(sub<32) return d12[rel];
02324       else            return m12[rel];
02325     }
02326   }
02327   else if(i==2)
02328   {
02329     if     (!o)
02330     {
02331       if     (sub<16) return b20[rel];
02332       else if(sub<32) return d20[rel];
02333       else            return m20[rel];
02334     }
02335     else if(o==1)
02336     {
02337       if     (sub<16) return b21[rel];
02338       else if(sub<32) return d21[rel];
02339       else            return m21[rel];
02340     }
02341     else if(o==2)     return 0;
02342   }
02343   return 7;
02344 }

G4int G4QPDGCode::GetSpin (  )  const [inline]

Definition at line 330 of file G4QPDGCode.hh.

References GetQuarkContent().

Referenced by G4QParticle::GetSpin().

00331 {
00332   if(thePDGCode<80000000)               return thePDGCode%10;
00333   else if(GetQuarkContent().GetTot()%2) return 3; // @@ Take into account higher resonances
00334   else                                  return 1;
00335 }

G4int G4QPDGCode::GetTotNumOfComb ( G4int  i  )  const

Definition at line 2368 of file G4QPDGCode.cc.

References G4cerr, and GetNumOfComb().

02369 {
02370   G4int tot=0;
02371   if(i>-1&&i<3) for(int j=0; j<3; j++) tot+=GetNumOfComb(i, j);
02372   else G4cerr<<"***G4QPDGCode:::GetTotNumOfComb: strange entering quark i="<<i<<G4endl;
02373   return tot;
02374 }

G4double G4QPDGCode::GetWidth (  ) 

Definition at line 740 of file G4QPDGCode.cc.

Referenced by G4QParticle::GetWidth(), and G4QHadron::RandomizeMass().

00741 {
00742   //static const int nW = 72;
00743   //static const int nW = 80; // "Isobars"
00744   //static G4double width[nQHM] = {0.,0.,0.,0.,0.,0.,0.,2.495,2.118,10.
00745   //  ,  10., 800.,  75., 350.,   0.,   0., .00118,  0.,   0., .203
00746   //  ,   0.,   0.,   0.,   0.,   0.,   0.,   0.,    0., 160., 160.
00747   //  , 8.41, 50.5, 50.8, 4.43, 120., 120., 120.,  120., 15.6,  39.
00748   //  ,  36., 35.8,  10.,   9.,   0., 107., 107., 185.5, 109., 98.5
00749   //  ,  76., 130., 130.,  80., 120., 120., 120.,   20.,  20., 160.
00750   //  , 160., 168., 159., 159.,  87., 300., 300.,  300., 300., 200.
00751   //  , 180., 180., 180.,  99.,  99.,  55., 387.,  387., 208., 198.
00752   //  , 198., 149., 120., 120., 170., 170., 120.,  120., 170., 170.};
00753   // Reduced:
00754   static G4double width[nQHM] = {0.,0.,0.,0.,0.,0.,0.,2.495,2.118,10.
00755     ,  10., 800.,  75., 350.,   0.,   0., .00118,  0.,   0., .203
00756     ,   0.,   0.,   0.,   0.,   0.,   0.,   0.,    0., 160., 160.
00757     , 8.41, 50.5, 50.8, 4.43, 120., 120., 120.,  120., 15.6,  39.
00758     ,  36., 35.8,  10.,   9.,   0., 120., 120.,  170., 170., 120.
00759     , 120., 170., 170.};
00760   G4int ab=abs(theQCode);
00761   if(ab<nQHM) return width[ab];
00762   return 0.;             // @@ May be real width should be implemented for nuclei e.g. pp
00763 }

void G4QPDGCode::InitByQCode ( G4int  QCode  )  [inline]

Definition at line 356 of file G4QPDGCode.hh.

Referenced by GetNumOfComb(), G4QNucleus::InitCandidateVector(), and G4QParticle::InitQParticle().

00357 {
00358   theQCode   = QCode;
00359   thePDGCode = MakePDGCode(QCode);
00360 }

void G4QPDGCode::InitByQCont ( G4QContent  QCont  )  [inline]

Definition at line 348 of file G4QPDGCode.hh.

References G4QContent::GetSPDGCode().

Referenced by G4QChipolino::G4QChipolino(), G4QHadron::G4QHadron(), and G4QPDGCode().

00349 {
00350   thePDGCode = QCont.GetSPDGCode();
00351   if(!thePDGCode) theQCode = -2;
00352   else theQCode   = MakeQCode(thePDGCode);
00353 }

std::pair< G4int, G4int > G4QPDGCode::MakeTwoBaryons ( G4int  L1,
G4int  L2,
G4int  R1,
G4int  R2 
)

Definition at line 2413 of file G4QPDGCode.cc.

References G4cout.

Referenced by G4QFragmentation::G4QFragmentation(), and G4QIonIonCollision::G4QIonIonCollision().

02414 {
02415   G4int dl=0;
02416   G4int ul=0;
02417   //G4int sl=0;
02418   if     (L1==1) ++dl;
02419   else if(L1==2) ++ul;
02420   //else if(L1==3) ++sl;
02421   if     (L2==1) ++dl;
02422   else if(L2==2) ++ul;
02423   //else if(L2==3) ++sl;
02424   if     (R1==1) ++dl;
02425   else if(R1==2) ++ul;
02426   //else if(R1==3) ++sl;
02427   if     (R2==1) ++dl;
02428   else if(R2==2) ++ul;
02429   //else if(R2==3) ++sl;
02430   if     (dl==2 && ul==2) return make_pair(1114,2212); // @@ can be (2112,2224)
02431   else if(dl==1 && ul==2) return make_pair(3112,2212);
02432   else if(dl==0 && ul==2) return make_pair(3212,3212); // @@ can be (3312,2212)
02433   else if(dl==2 && ul==1) return make_pair(3222,2112);
02434   else if(dl==1 && ul==1) return make_pair(3312,2112); // @@ can be (3322,2212)
02435   else if(dl==2 && ul==0) return make_pair(3112,3112); // @@ can be (3322,1122)
02436   //#ifdef debug
02437   else G4cout<<"-Warning-G4QPDGCode::MakeTwoBaryons: Irreduceble? L1="<<L1<<",L2="<<L2
02438              <<",R1="<<R1<<",R2="<<R2<<G4endl;
02439   //#endif
02440   return make_pair(2212,2112);                         // @@ Just theMinimum, makeException
02441 }

void G4QPDGCode::NegPDGCode (  )  [inline]

Definition at line 336 of file G4QPDGCode.hh.

Referenced by G4QHadron::NegPDGCode().

00336 {thePDGCode=-thePDGCode;}

G4QPDGCode G4QPDGCode::operator *= ( const G4int rhs  )  [inline]

Definition at line 266 of file G4QPDGCode.hh.

00267 {
00268   thePDGCode*=rhs;
00269   if(!thePDGCode) theQCode = -2;
00270   else theQCode = MakeQCode(thePDGCode);
00271   return *this;
00272 }

G4bool G4QPDGCode::operator!= ( const G4int rhs  )  const [inline]

Definition at line 234 of file G4QPDGCode.hh.

00234 {return thePDGCode!=rhs;}

G4bool G4QPDGCode::operator!= ( const G4QPDGCode rhs  )  const [inline]

Definition at line 233 of file G4QPDGCode.hh.

00233 {return this!=&rhs;}

G4QPDGCode G4QPDGCode::operator+= ( const G4QPDGCode rhs  )  [inline]

Definition at line 238 of file G4QPDGCode.hh.

References GetPDGCode().

00239 {
00240   thePDGCode+=rhs.GetPDGCode();
00241   if(!thePDGCode) theQCode = -2;
00242   else theQCode = MakeQCode(thePDGCode);
00243   return *this;
00244 }

G4QPDGCode G4QPDGCode::operator+= ( const G4int rhs  )  [inline]

Definition at line 245 of file G4QPDGCode.hh.

00246 {
00247   thePDGCode+=rhs;
00248   if(!thePDGCode) theQCode = -2;
00249   else theQCode = MakeQCode(thePDGCode);
00250   return *this;
00251 }

G4QPDGCode G4QPDGCode::operator-= ( const G4QPDGCode rhs  )  [inline]

Definition at line 252 of file G4QPDGCode.hh.

References GetPDGCode().

00253 {
00254   thePDGCode-=rhs.GetPDGCode();
00255   if(!thePDGCode) theQCode = -2;
00256   else theQCode = MakeQCode(thePDGCode);
00257   return *this;
00258 }

G4QPDGCode G4QPDGCode::operator-= ( const G4int rhs  )  [inline]

Definition at line 259 of file G4QPDGCode.hh.

00260 {
00261   thePDGCode-=rhs;
00262   if(!thePDGCode) theQCode = -2;
00263   else theQCode = MakeQCode(thePDGCode);
00264   return *this;
00265 }

G4QPDGCode G4QPDGCode::operator/= ( const G4int rhs  )  [inline]

Definition at line 273 of file G4QPDGCode.hh.

00274 {
00275   thePDGCode/=rhs;
00276   if(!thePDGCode) theQCode = -2;
00277   else theQCode = MakeQCode(thePDGCode);
00278   return *this;
00279 }

const G4QPDGCode & G4QPDGCode::operator= ( const G4QPDGCode rhs  ) 

Definition at line 105 of file G4QPDGCode.cc.

References thePDGCode, and theQCode.

00106 {
00107   if(this != &rhs)                          // Beware of self assignment
00108   {
00109     thePDGCode =rhs.thePDGCode;
00110     theQCode   =rhs.theQCode;
00111   }
00112   return *this;
00113 }

G4bool G4QPDGCode::operator== ( const G4int rhs  )  const [inline]

Definition at line 232 of file G4QPDGCode.hh.

00232 {return thePDGCode==rhs;}

G4bool G4QPDGCode::operator== ( const G4QPDGCode rhs  )  const [inline]

Definition at line 231 of file G4QPDGCode.hh.

00231 {return this==&rhs;}

void G4QPDGCode::SetPDGCode ( G4int  newPDGCode  )  [inline]

Definition at line 340 of file G4QPDGCode.hh.

Referenced by G4QHadron::G4QHadron(), and G4QChipolino::SetHadronPDGCode().

00341 {
00342   thePDGCode=newPDGCode;
00343   if(!thePDGCode) theQCode = -2;
00344   else theQCode = MakeQCode(newPDGCode);
00345 }

G4bool G4QPDGCode::TestRealNeutral (  )  [inline]

Definition at line 337 of file G4QPDGCode.hh.

Referenced by G4QHadron::TestRealNeutral().

00337 {return TestRealNeutral(thePDGCode);}


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:13 2013 for Geant4 by  doxygen 1.4.7