G4HEInelastic Class Reference

#include <G4HEInelastic.hh>

Inheritance diagram for G4HEInelastic:

G4HadronicInteraction G4HEAntiKaonZeroInelastic G4HEAntiLambdaInelastic G4HEAntiNeutronInelastic G4HEAntiOmegaMinusInelastic G4HEAntiProtonInelastic G4HEAntiSigmaMinusInelastic G4HEAntiSigmaPlusInelastic G4HEAntiSigmaZeroInelastic G4HEAntiXiMinusInelastic G4HEAntiXiZeroInelastic G4HEKaonMinusInelastic G4HEKaonPlusInelastic G4HEKaonZeroInelastic G4HEKaonZeroLongInelastic G4HEKaonZeroShortInelastic G4HELambdaInelastic G4HENeutronInelastic G4HEOmegaMinusInelastic G4HEPionMinusInelastic G4HEPionPlusInelastic G4HEProtonInelastic G4HESigmaMinusInelastic G4HESigmaPlusInelastic G4HESigmaZeroInelastic G4HEXiMinusInelastic G4HEXiZeroInelastic

Public Member Functions

 G4HEInelastic (const G4String &modelName="HEInelastic")
 ~G4HEInelastic ()
void SetMaxNumberOfSecondaries (const G4int maxnumber)
void SetVerboseLevel (const G4int level)
void ForceEnergyConservation (G4bool energyConservation)
G4bool EnergyConservation (void)
virtual const std::pair< G4double,
G4double
GetFatalEnergyCheckLevels () const
G4double Amin (G4double a, G4double b)
G4double Amax (G4double a, G4double b)
G4int Imin (G4int a, G4int b)
G4int Imax (G4int a, G4int b)
void FillParticleChange (G4HEVector pv[], G4int aVecLength)
G4double pmltpc (G4int np, G4int nm, G4int nz, G4int n, G4double b, G4double c)
G4int Factorial (G4int n)
G4double NuclearInelasticity (G4double incidentKineticEnergy, G4double atomicWeight, G4double atomicNumber)
G4double NuclearExcitation (G4double incidentKineticEnergy, G4double atomicWeight, G4double atomicNumber, G4double &excitationEnergyCascade, G4double &excitationEnergyEvaporation)
void HighEnergyCascading (G4bool &successful, G4HEVector pv[], G4int &vecLen, G4double &excitationEnergyGNP, G4double &excitationEnergyDTA, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void HighEnergyClusterProduction (G4bool &successful, G4HEVector pv[], G4int &vecLen, G4double &excitationEnergyGNP, G4double &excitationEnergyDTA, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void TuningOfHighEnergyCascading (G4HEVector pv[], G4int &vecLen, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void MediumEnergyCascading (G4bool &successful, G4HEVector pv[], G4int &vecLen, G4double &excitationEnergyGNP, G4double &excitationEnergyDTA, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void MediumEnergyClusterProduction (G4bool &successful, G4HEVector pv[], G4int &vecLen, G4double &excitationEnergyGNP, G4double &excitationEnergyDTA, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void QuasiElasticScattering (G4bool &successful, G4HEVector pv[], G4int &vecLen, G4double &excitationEnergyGNP, G4double &excitationEnergyDTA, const G4HEVector &incidentParticle, const G4HEVector &targetParticle, G4double atomicWeight, G4double atomicNumber)
void ElasticScattering (G4bool &successful, G4HEVector pv[], G4int &vecLen, const G4HEVector &incidentParticle, G4double atomicWeight, G4double atomicNumber)
G4int rtmi (G4double *x, G4double xli, G4double xri, G4double eps, G4int iend, G4double aa, G4double bb, G4double cc, G4double dd, G4double rr)
G4double fctcos (G4double t, G4double aa, G4double bb, G4double cc, G4double dd, G4double rr)
void StrangeParticlePairProduction (const G4double availableEnergy, const G4double centerOfMassEnergy, G4HEVector pv[], G4int &vecLen, const G4HEVector &incidentParticle, const G4HEVector &targetParticle)
G4double NBodyPhaseSpace (const G4double totalEnergy, const G4bool constantCrossSection, G4HEVector pv[], G4int &vecLen)
G4double NBodyPhaseSpace (G4int npart, G4HEVector pv[], G4double wmax, G4double wfcn, G4int maxtrial, G4int ntrial)
G4double gpdk (G4double a, G4double b, G4double c)
void QuickSort (G4double arr[], const G4int lidx, const G4int ridx)
G4double Alam (G4double a, G4double b, G4double c)
G4double CalculatePhaseSpaceWeight (G4int npart)
G4double normal (void)
G4double GammaRand (G4double avalue)
G4double Erlang (G4int mvalue)
G4int Poisson (G4double x)
void SetParticles (void)

Data Fields

G4int verboseLevel
G4int MAXPART
G4bool conserveEnergy
G4HEVector PionPlus
G4HEVector PionZero
G4HEVector PionMinus
G4HEVector KaonPlus
G4HEVector KaonZero
G4HEVector AntiKaonZero
G4HEVector KaonMinus
G4HEVector KaonZeroShort
G4HEVector KaonZeroLong
G4HEVector Proton
G4HEVector AntiProton
G4HEVector Neutron
G4HEVector AntiNeutron
G4HEVector Lambda
G4HEVector AntiLambda
G4HEVector SigmaPlus
G4HEVector SigmaZero
G4HEVector SigmaMinus
G4HEVector AntiSigmaPlus
G4HEVector AntiSigmaZero
G4HEVector AntiSigmaMinus
G4HEVector XiZero
G4HEVector XiMinus
G4HEVector AntiXiZero
G4HEVector AntiXiMinus
G4HEVector OmegaMinus
G4HEVector AntiOmegaMinus
G4HEVector Deuteron
G4HEVector Triton
G4HEVector Alpha
G4HEVector Gamma

Detailed Description

Definition at line 59 of file G4HEInelastic.hh.


Constructor & Destructor Documentation

G4HEInelastic::G4HEInelastic ( const G4String modelName = "HEInelastic"  )  [inline]

Definition at line 62 of file G4HEInelastic.hh.

References conserveEnergy, MAXPART, SetParticles(), and verboseLevel.

00063     : G4HadronicInteraction(modelName)
00064    { 
00065      SetParticles();
00066      verboseLevel = 0;
00067      MAXPART = 0;
00068      conserveEnergy = true;
00069    };

G4HEInelastic::~G4HEInelastic (  )  [inline]

Definition at line 71 of file G4HEInelastic.hh.

00071 { };


Member Function Documentation

G4double G4HEInelastic::Alam ( G4double  a,
G4double  b,
G4double  c 
)

Definition at line 5735 of file G4HEInelastic.cc.

Referenced by NBodyPhaseSpace().

05736  { return a*a + b*b + c*c - 2.*a*b - 2.*a*c -2.*b*c;
05737  }    

G4double G4HEInelastic::Amax ( G4double  a,
G4double  b 
)

Definition at line 125 of file G4HEInelastic.cc.

Referenced by ElasticScattering(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), NBodyPhaseSpace(), NuclearExcitation(), NuclearInelasticity(), pmltpc(), Poisson(), QuasiElasticScattering(), and TuningOfHighEnergyCascading().

00126 {
00127   G4double c = a;
00128   if(b > a) c = b;
00129   return c;
00130 }

G4double G4HEInelastic::Amin ( G4double  a,
G4double  b 
)

Definition at line 118 of file G4HEInelastic.cc.

Referenced by G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), NBodyPhaseSpace(), NuclearExcitation(), NuclearInelasticity(), pmltpc(), and QuasiElasticScattering().

00119 {
00120   G4double c = a;
00121   if(b < a) c = b;
00122   return c;
00123 }

G4double G4HEInelastic::CalculatePhaseSpaceWeight ( G4int  npart  ) 

Definition at line 5740 of file G4HEInelastic.cc.

Referenced by NBodyPhaseSpace().

05741  { G4double wfcn = 1.;
05742    return wfcn;
05743  }      

void G4HEInelastic::ElasticScattering ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
const G4HEVector incidentParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 5183 of file G4HEInelastic.cc.

References Amax(), G4HEVector::Defs1(), fctcos(), G4cout, G4endl, G4UniformRand, G4HEVector::getMass(), G4HEVector::getMomentum(), G4HEVector::getTotalMomentum(), rtmi(), G4HEVector::setMass(), G4HEVector::setMomentum(), G4HEVector::setMomentumAndUpdate(), G4HEVector::SmulAndUpdate(), sqr(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

05189 {
05190   if (verboseLevel > 1) 
05191     G4cout << " G4HEInelastic::ElasticScattering " << G4endl;
05192 
05193   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
05194   if (verboseLevel > 1)
05195     G4cout << "DoIt: Incident particle momentum=" 
05196            << incidentTotalMomentum << " GeV" << G4endl;
05197   if (incidentTotalMomentum < 0.01) { 
05198       successful = false;
05199       return;
05200   }
05201 
05202    if (atomicWeight < 0.5) 
05203       { 
05204         successful = false;
05205         return;
05206       }
05207    pv[0] = incidentParticle;
05208    vecLen = 1;
05209 
05210    G4double aa, bb, cc, dd, rr;
05211    if (atomicWeight <= 62.) 
05212      {
05213        aa = std::pow(atomicWeight, 1.63);
05214        bb = 14.5*std::pow(atomicWeight, 0.66);
05215        cc = 1.4*std::pow(atomicWeight, 0.33);
05216        dd = 10.;
05217      }
05218    else 
05219      {
05220        aa = std::pow(atomicWeight, 1.33);
05221        bb = 60.*std::pow(atomicWeight, 0.33);
05222        cc = 0.4*std::pow(atomicWeight, 0.40);
05223        dd = 10.;
05224      }
05225    aa = aa/bb;
05226    cc = cc/dd;
05227    G4double ran = G4UniformRand();
05228    rr = (aa + cc)*ran;
05229    if (verboseLevel > 1) 
05230      {
05231        G4cout << "ElasticScattering: aa,bb,cc,dd,rr" << G4endl;
05232        G4cout << aa << " " << bb << " " << cc << " " << dd << " " 
05233               << rr << G4endl;
05234      }
05235    G4double t1 = -std::log(ran)/bb;
05236    G4double t2 = -std::log(ran)/dd;
05237    if (verboseLevel > 1) {
05238        G4cout << "t1,fctcos " << t1 << " " << fctcos(t1, aa, bb, cc, dd, rr) 
05239               << G4endl;
05240        G4cout << "t2,fctcos " << t2 << " " << fctcos(t2, aa, bb, cc, dd, rr) 
05241               << G4endl;
05242    }
05243    G4double eps = 0.001;
05244    G4int ind1 = 10;
05245    G4double t;
05246    G4int ier1;
05247    ier1 = rtmi(&t, t1, t2, eps, ind1, aa, bb, cc, dd, rr);
05248    if (verboseLevel > 1) {
05249      G4cout << "From rtmi, ier1=" << ier1 << G4endl;
05250      G4cout << "t, fctcos " << t << " " << fctcos(t, aa, bb, cc, dd, rr) 
05251             << G4endl;
05252    }
05253    if (ier1 != 0) t = 0.25*(3.*t1 + t2);
05254    if (verboseLevel > 1) 
05255      G4cout << "t, fctcos " << t << " " << fctcos(t, aa, bb, cc, dd, rr) 
05256             << G4endl;
05257 
05258    G4double phi = G4UniformRand()*twopi;
05259    rr = 0.5*t/sqr(incidentTotalMomentum);
05260    if (rr > 1.) rr = 0.;
05261    if (verboseLevel > 1)
05262       G4cout << "rr=" << rr << G4endl;
05263    G4double cost = 1. - rr;
05264    G4double sint = std::sqrt(Amax(rr*(2. - rr), 0.));
05265    if (verboseLevel > 1)
05266       G4cout << "cos(t)=" << cost << "  std::sin(t)=" << sint << G4endl;
05267                                          // Scattered particle referred to axis of incident particle
05268    G4HEVector pv0;
05269    G4HEVector pvI;
05270    pvI.setMass( incidentParticle.getMass() );
05271    pvI.setMomentum( incidentParticle.getMomentum() );
05272    pvI.SmulAndUpdate( pvI, 1. );    
05273    pv0.setMass( pvI.getMass() );
05274    
05275    pv0.setMomentumAndUpdate( incidentTotalMomentum * sint * std::sin(phi),
05276                              incidentTotalMomentum * sint * std::cos(phi),
05277                              incidentTotalMomentum * cost           );    
05278    pv0.Defs1( pv0, pvI );
05279       
05280    successful = true;
05281    return;
05282  }

G4bool G4HEInelastic::EnergyConservation ( void   )  [inline]

Definition at line 85 of file G4HEInelastic.hh.

References conserveEnergy.

00085 {return conserveEnergy;} 

G4double G4HEInelastic::Erlang ( G4int  mvalue  ) 

Definition at line 320 of file G4HEInelastic.cc.

References G4UniformRand.

Referenced by HighEnergyCascading(), and HighEnergyClusterProduction().

00321  {
00322    G4double ran = G4UniformRand();
00323    G4double xtrial = 0.62666*std::log((1.+ran)/(1.-ran));
00324    if(G4UniformRand()<0.5) xtrial = -xtrial;
00325    return mvalue+xtrial*std::sqrt(G4double(mvalue));
00326  }  

G4int G4HEInelastic::Factorial ( G4int  n  ) 

Definition at line 249 of file G4HEInelastic.cc.

References FatalException, and G4Exception().

Referenced by G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEProtonInelastic::FirstIntInCasProton(), NBodyPhaseSpace(), and Poisson().

00250 { 
00251   G4int result = 1;
00252   if (n < 0) G4Exception("G4HEInelastic::Factorial()", "HEP000",
00253                          FatalException, "Negative factorial argument");
00254   while (n > 1) result *= n--;
00255   return result;
00256 } 

G4double G4HEInelastic::fctcos ( G4double  t,
G4double  aa,
G4double  bb,
G4double  cc,
G4double  dd,
G4double  rr 
)

Definition at line 5405 of file G4HEInelastic.cc.

Referenced by ElasticScattering(), and rtmi().

05407  {
05408    const G4double expxl = -82.;
05409    const G4double expxu = 82.;
05410 
05411    G4double test1 = -bb*t;
05412    if (test1 > expxu) test1 = expxu;
05413    if (test1 < expxl) test1 = expxl;
05414 
05415    G4double test2 = -dd*t;
05416    if (test2 > expxu) test2 = expxu;
05417    if (test2 < expxl) test2 = expxl;
05418 
05419    return aa*std::exp(test1) + cc*std::exp(test2) - rr;
05420  }

void G4HEInelastic::FillParticleChange ( G4HEVector  pv[],
G4int  aVecLength 
)

Definition at line 57 of file G4HEInelastic.cc.

References G4HadFinalState::AddSecondary(), G4Alpha::Alpha(), G4HadFinalState::Clear(), G4Deuteron::Deuteron(), G4ParticleTable::FindParticle(), G4ParticleTable::GetParticleTable(), G4DynamicParticle::SetDefinition(), G4DynamicParticle::SetMomentum(), G4HadronicInteraction::theParticleChange, and G4Triton::Triton().

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

00058 {
00059   theParticleChange.Clear();
00060   for (G4int i=0; i<aVecLength; i++)
00061   {
00062     G4int pdgCode = pv[i].getCode();
00063     G4ParticleDefinition * aDefinition=NULL;
00064     if(pdgCode == 0)
00065     {
00066       G4int bNumber = pv[i].getBaryonNumber();
00067       if(bNumber==2) aDefinition = G4Deuteron::Deuteron();
00068       if(bNumber==3) aDefinition = G4Triton::Triton();
00069       if(bNumber==4) aDefinition = G4Alpha::Alpha();
00070     }
00071     else
00072     {
00073      aDefinition =  G4ParticleTable::GetParticleTable()->FindParticle(pdgCode);
00074     }
00075     G4DynamicParticle * aParticle = new G4DynamicParticle();
00076     aParticle->SetDefinition(aDefinition);
00077     aParticle->SetMomentum(pv[i].getMomentum()*GeV);
00078     theParticleChange.AddSecondary(aParticle);
00079   }
00080 }

void G4HEInelastic::ForceEnergyConservation ( G4bool  energyConservation  )  [inline]

Definition at line 82 of file G4HEInelastic.hh.

References conserveEnergy.

00083               {conserveEnergy = energyConservation;}

G4double G4HEInelastic::GammaRand ( G4double  avalue  ) 

Definition at line 304 of file G4HEInelastic.cc.

References G4UniformRand, and sqr().

Referenced by HighEnergyCascading(), and HighEnergyClusterProduction().

00305  {
00306    G4double ga = avalue -1.;
00307    G4double la = std::sqrt(2.*avalue - 1.);
00308    G4double ep = 1.570796327 + std::atan(ga/la);
00309    G4double ro = 1.570796327 - ep;
00310    G4double y  = 1.;
00311    G4double xtrial;
00312    repeat:
00313    xtrial = ga + la * std::tan(ep*G4UniformRand() + ro);
00314    if(xtrial == 0.) goto repeat;
00315    y = std::log(1.+sqr((xtrial-ga)/la))+ga*std::log(xtrial/ga)-xtrial+ga;
00316    if(std::log(G4UniformRand()) > y) goto repeat;  
00317    return xtrial;
00318  }

const std::pair< G4double, G4double > G4HEInelastic::GetFatalEnergyCheckLevels (  )  const [virtual]

Reimplemented from G4HadronicInteraction.

Definition at line 5745 of file G4HEInelastic.cc.

05746 {
05747         // max energy non-conservation is mass of heavy nucleus
05748         return std::pair<G4double, G4double>(5*perCent,250*GeV);
05749 }

G4double G4HEInelastic::gpdk ( G4double  a,
G4double  b,
G4double  c 
)

Definition at line 5617 of file G4HEInelastic.cc.

05618  {
05619    if( a == 0.0 ) 
05620      {
05621        return 0.0;
05622       } 
05623    else 
05624       {
05625         G4double arg = a*a+(b*b-c*c)*(b*b-c*c)/(a*a)-2.0*(b*b+c*c);
05626         if( arg <= 0.0 ) 
05627           {
05628             return 0.0;
05629           } 
05630         else 
05631           {
05632             return 0.5*std::sqrt(std::fabs(arg));
05633           }
05634       }
05635  }

void G4HEInelastic::HighEnergyCascading ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
G4double excitationEnergyGNP,
G4double excitationEnergyDTA,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 598 of file G4HEInelastic.cc.

References G4HEVector::Add(), Alpha, Amax(), Amin(), G4HEVector::Ang(), AntiKaonZero, AntiProton, G4HEVector::Defs1(), Deuteron, Erlang(), G4cout, G4endl, G4UniformRand, GammaRand(), G4HEVector::getCode(), G4HEVector::getEnergy(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getMomentum(), G4HEVector::getSide(), G4HEVector::getTotalMomentum(), G4HEVector::getType(), Imin(), KaonMinus, KaonPlus, KaonZero, KaonZeroLong, KaonZeroShort, Lambda, G4HEVector::Length(), G4HEVector::Lor(), NBodyPhaseSpace(), Neutron, neutronCode, normal(), NuclearExcitation(), PionMinus, PionPlus, PionZero, Poisson(), G4InuclParticleNames::pp, G4HEVector::Print(), Proton, G4HEVector::setDefinition(), G4HEVector::setEnergy(), G4HEVector::setEnergyAndUpdate(), G4HEVector::setFlag(), G4HEVector::setKineticEnergy(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMass(), G4HEVector::setMomentum(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setSide(), G4HEVector::setTOF(), G4HEVector::setZero(), SigmaZero, G4HEVector::SmulAndUpdate(), sqr(), Triton, TuningOfHighEnergyCascading(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

00607 {   
00608   //  The multiplicity of particles produced in the first interaction has been
00609   //  calculated in one of the FirstIntInNuc.... routines. The nuclear
00610   //  cascading particles are parameterized from experimental data.
00611   //  A simple single variable description E D3S/DP3= F(Q) with
00612   //  Q^2 = (M*X)^2 + PT^2 is used. Final state kinematics are produced
00613   //  by an FF-type iterative cascade method.
00614   //  Nuclear evaporation particles are added at the end of the routine.
00615 
00616   //  All quantities in the G4HEVector Array pv are in GeV- units.
00617   //  The method is a copy of MediumEnergyCascading with some special tuning
00618   //  for high energy interactions.
00619 
00620   G4int protonCode = Proton.getCode();
00621   G4double protonMass = Proton.getMass();
00622   G4int neutronCode = Neutron.getCode();
00623   G4double neutronMass = Neutron.getMass();
00624   G4double kaonPlusMass = KaonPlus.getMass();
00625   G4int kaonPlusCode = KaonPlus.getCode();   
00626   G4int kaonMinusCode = KaonMinus.getCode();
00627   G4int kaonZeroSCode = KaonZeroShort.getCode(); 
00628   G4int kaonZeroLCode = KaonZeroLong.getCode();
00629   G4int kaonZeroCode = KaonZero.getCode();
00630   G4int antiKaonZeroCode = AntiKaonZero.getCode(); 
00631   G4int pionPlusCode = PionPlus.getCode();    
00632   G4int pionZeroCode = PionZero.getCode();    
00633   G4int pionMinusCode = PionMinus.getCode(); 
00634   G4String mesonType = PionPlus.getType();
00635   G4String baryonType = Proton.getType(); 
00636   G4String antiBaryonType = AntiProton.getType(); 
00637 
00638   G4double targetMass = targetParticle.getMass();
00639 
00640   G4int incidentCode = incidentParticle.getCode();
00641   G4double incidentMass = incidentParticle.getMass();
00642   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
00643   G4double incidentEnergy = incidentParticle.getEnergy();
00644   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
00645   G4String incidentType = incidentParticle.getType();
00646 //   G4double incidentTOF           = incidentParticle.getTOF();   
00647   G4double incidentTOF = 0.;
00648    
00649   // some local variables
00650 
00651   G4int i, j, l;
00652 
00653   if (verboseLevel > 1) G4cout << " G4HEInelastic::HighEnergyCascading "
00654                                << G4endl;
00655   successful = false; 
00656   if (incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
00657  
00658   // define annihilation channels.
00659                                  
00660   G4bool annihilation = false;
00661   if (incidentCode < 0 && incidentType == antiBaryonType && 
00662       pv[0].getType() != antiBaryonType &&
00663       pv[1].getType() != antiBaryonType) { 
00664     annihilation = true;
00665   }   
00666 
00667   G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
00668 
00669   if (annihilation) goto start;
00670   if (vecLen >= 8)   goto start;
00671   if( incidentKineticEnergy < 1.) return; 
00672   if(   (   incidentCode == kaonPlusCode  || incidentCode == kaonMinusCode
00673          || incidentCode == kaonZeroCode  || incidentCode == antiKaonZeroCode
00674          || incidentCode == kaonZeroSCode || incidentCode == kaonZeroLCode )
00675      && (   G4UniformRand() < 0.5) ) goto start;
00676   if( G4UniformRand() > twsup[vecLen-1]) goto start;
00677   if( incidentKineticEnergy > (G4UniformRand()*200 + 50.) ) goto start;
00678   return;
00679    
00680   start:
00681 
00682   if (annihilation) {
00683     // do some corrections of incident particle kinematic
00684     G4double ekcor = Amax( 1., 1./incidentKineticEnergy);
00685     incidentKineticEnergy = 2*targetMass + incidentKineticEnergy*(1.+ekcor/atomicWeight);
00686     G4double excitation = NuclearExcitation(incidentKineticEnergy,
00687                                             atomicWeight,
00688                                             atomicNumber,
00689                                             excitationEnergyGNP,
00690                                             excitationEnergyDTA);
00691     incidentKineticEnergy -= excitation;
00692     if (incidentKineticEnergy < excitationEnergyDTA) incidentKineticEnergy = 0.;
00693     incidentEnergy = incidentKineticEnergy + incidentMass;
00694     incidentTotalMomentum =
00695          std::sqrt( Amax(0., incidentEnergy*incidentEnergy - incidentMass*incidentMass));
00696   }
00697     
00698   G4HEVector pTemp;
00699   for (i = 2; i < vecLen; i++) {
00700     j = Imin( vecLen-1, (G4int)(2. + G4UniformRand()*(vecLen - 2)));
00701     pTemp = pv[j];
00702     pv[j] = pv[i];
00703     pv[i] = pTemp;
00704   }
00705   // randomize the first two leading particles
00706   // for kaon induced reactions only 
00707   // (need from experimental data)
00708 
00709   if ((incidentCode==kaonPlusCode  || incidentCode==kaonMinusCode    ||
00710        incidentCode==kaonZeroCode  || incidentCode==antiKaonZeroCode ||
00711        incidentCode==kaonZeroSCode || incidentCode==kaonZeroLCode)   
00712       && (G4UniformRand() > 0.9) ) {
00713     pTemp = pv[1];
00714     pv[1] = pv[0];
00715     pv[0] = pTemp;
00716   }
00717 
00718   // mark leading particles for incident strange particles 
00719   // and antibaryons, for all other we assume that the first 
00720   // and second particle are the leading particles. 
00721   // We need this later for kinematic aspects of strangeness
00722   // conservation.
00723                           
00724   G4int lead = 0;                   
00725   G4HEVector leadParticle;
00726   if ((incidentMass >= kaonPlusMass-0.05) &&
00727       (incidentCode != protonCode) && (incidentCode != neutronCode) ) {
00728     G4double pMass = pv[0].getMass();
00729     G4int pCode = pv[0].getCode();
00730     if ((pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
00731                                      && (pCode != neutronCode) ) {       
00732       lead = pCode; 
00733       leadParticle = pv[0];                           
00734     } else {
00735       pMass = pv[1].getMass();
00736       pCode = pv[1].getCode();
00737       if ((pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
00738                                        && (pCode != neutronCode) ) {       
00739         lead = pCode;
00740         leadParticle = pv[1];
00741       }
00742     }
00743   }
00744 
00745   // Distribute particles in forward and backward hemispheres in center 
00746   // of mass system.  Incident particle goes in forward hemisphere.
00747    
00748   G4HEVector pvI = incidentParticle;  // for the incident particle
00749   pvI.setSide( 1 );
00750 
00751   G4HEVector pvT = targetParticle;   // for the target particle
00752   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
00753   pvT.setSide( -1 );
00754   pvT.setTOF( -1.); 
00755 
00756   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass)+sqr(targetMass)
00757                                       +2.0*targetMass*incidentEnergy );
00758 
00759   G4double tavai1 = centerOfMassEnergy/2.0 - incidentMass;
00760   G4double tavai2 = centerOfMassEnergy/2.0 - targetMass;           
00761    
00762   // define G4HEVector- array for kinematic manipulations,
00763   // with a one by one correspondence to the pv-Array. 
00764    
00765   G4int ntb = 1;
00766   for (i = 0; i < vecLen; i++) {
00767     if (i == 0) pv[i].setSide(1);
00768     else if (i == 1) pv[i].setSide(-1);
00769     else {
00770       if (G4UniformRand() < 0.5) {
00771         pv[i].setSide(-1);
00772         ntb++;
00773       } else {
00774         pv[i].setSide(1);
00775       }
00776     }
00777     pv[i].setTOF(incidentTOF);
00778   }
00779 
00780   G4double tb = 2. * ntb;
00781   if (centerOfMassEnergy < (2. + G4UniformRand())) 
00782     tb = (2. * ntb + vecLen)/2.;     
00783 
00784   if (verboseLevel > 1) {
00785     G4cout << " pv Vector after Randomization " << vecLen << G4endl;
00786     pvI.Print(-1);
00787     pvT.Print(-1);
00788     for (i = 0; i < vecLen; i++) pv[i].Print(i);
00789   }
00790 
00791   // Add particles from intranuclear cascade
00792   // nuclearCascadeCount = number of new secondaries produced by nuclear 
00793   // cascading.
00794   // extraCount = number of nucleons within these new secondaries
00795 
00796   G4double ss, xtarg, ran;
00797   ss = centerOfMassEnergy*centerOfMassEnergy;
00798   G4double afc;
00799   afc = Amin(0.5, 0.312 + 0.200 * std::log(std::log(ss))+ std::pow(ss,1.5)/6000.0); 
00800   xtarg = Amax(0.01, afc * (std::pow(atomicWeight, 0.33) - 1.0) * tb);
00801   G4int nstran = Poisson( 0.03*xtarg);
00802   G4int momentumBin = 0;
00803   G4double nucsup[] = { 1.00, 0.7, 0.5, 0.4, 0.5, 0.5 };
00804   G4double psup[]   = {   3.,  6., 20., 50., 100., 1000. };
00805   while( (momentumBin < 6) && (incidentTotalMomentum > psup[momentumBin])) momentumBin++;
00806   momentumBin = Imin(5, momentumBin);
00807   G4double xpnhmf = Amax(0.01,xtarg*nucsup[momentumBin]);
00808   G4double xshhmf = Amax(0.01,xtarg - xpnhmf);
00809   G4double rshhmf = 0.25*xshhmf;
00810   G4double rpnhmf = 0.81*xpnhmf;
00811   G4double xhmf=0;
00812   if (verboseLevel > 1)
00813     G4cout << "xtarg= " << xtarg << " xpnhmf = " << xpnhmf << G4endl;
00814 
00815   G4int nshhmf, npnhmf;
00816   if (rshhmf > 1.1) {
00817         rshhmf = xshhmf/(rshhmf-1.);
00818         if (rshhmf <= 20.) 
00819             xhmf = GammaRand( rshhmf );
00820         else
00821             xhmf = Erlang( G4int(rshhmf+0.5) );
00822         xshhmf *= xhmf/rshhmf;
00823   }
00824    nshhmf = Poisson( xshhmf );   
00825    if(verboseLevel > 1)
00826      G4cout << "xshhmf = " << xshhmf << " xhmf = " << xhmf 
00827             << " rshhmf = " << rshhmf << G4endl;
00828 
00829    if (rpnhmf > 1.1)
00830      {
00831         rpnhmf = xpnhmf/(rpnhmf -1.);
00832         if (rpnhmf <= 20.)
00833             xhmf = GammaRand( rpnhmf );
00834         else
00835             xhmf = Erlang( G4int(rpnhmf+0.5) );
00836         xpnhmf *= xhmf/rpnhmf;
00837      }
00838    npnhmf = Poisson( xpnhmf );
00839    if(verboseLevel > 1)
00840      G4cout << "nshhmf = " << nshhmf << " npnhmf = " <<  npnhmf 
00841             << " nstran = " << nstran << G4endl;
00842 
00843    G4int ntarg = nshhmf + npnhmf + nstran;          
00844 
00845    G4int targ = 0;
00846    
00847    while (npnhmf > 0)  
00848      {
00849        if ( G4UniformRand() > (1. - atomicNumber/atomicWeight))
00850           pv[vecLen] = Proton;
00851        else
00852           pv[vecLen] = Neutron;
00853        targ++;
00854        pv[vecLen].setSide( -2 );
00855        pv[vecLen].setFlag( true );
00856        pv[vecLen].setTOF( incidentTOF );
00857        vecLen++;
00858        npnhmf--;
00859      }
00860    while (nstran > 0)
00861      {
00862        ran = G4UniformRand();
00863        if (ran < 0.14)      pv[vecLen] = Lambda;
00864        else if (ran < 0.20) pv[vecLen] = SigmaZero;
00865        else if (ran < 0.43) pv[vecLen] = KaonPlus;
00866        else if (ran < 0.66) pv[vecLen] = KaonZero;
00867        else if (ran < 0.89) pv[vecLen] = AntiKaonZero;
00868        else                 pv[vecLen] = KaonMinus;
00869        if (G4UniformRand() > 0.2)
00870          { 
00871            pv[vecLen].setSide( -2 );
00872            pv[vecLen].setFlag( true );
00873          } 
00874        else
00875          {
00876            pv[vecLen].setSide( 1 );
00877            pv[vecLen].setFlag( false );
00878            ntarg--;
00879          } 
00880        pv[vecLen].setTOF( incidentTOF );
00881        vecLen++;         
00882        nstran--;   
00883      } 
00884    while (nshhmf > 0)
00885      {
00886        ran = G4UniformRand();
00887        if( ran < 0.33333 ) 
00888            pv[vecLen] = PionPlus;
00889        else if( ran < 0.66667 ) 
00890            pv[vecLen] = PionZero;
00891        else 
00892            pv[vecLen] = PionMinus;
00893        if (G4UniformRand() > 0.2)
00894           {
00895             pv[vecLen].setSide( -2 );        // backward cascade particles
00896             pv[vecLen].setFlag( true );      // true is the same as IPA(i)<0
00897           }
00898        else
00899           {
00900             pv[vecLen].setSide( 1 );
00901             pv[vecLen].setFlag( false );
00902             ntarg--;
00903           }  
00904        pv[vecLen].setTOF( incidentTOF );
00905        vecLen++; 
00906        nshhmf--;
00907      }
00908                                          
00909   //  assume conservation of kinetic energy 
00910   //  in forward & backward hemispheres
00911 
00912   G4int is, iskip, iavai1;
00913   if (vecLen <= 1) return;
00914 
00915   tavai1 = centerOfMassEnergy/2.;
00916   iavai1 = 0;
00917  
00918   for (i = 0; i < vecLen; i++) 
00919        { 
00920          if (pv[i].getSide() > 0)
00921             { 
00922                tavai1 -= pv[i].getMass();
00923                iavai1++;
00924             }    
00925        } 
00926   if ( iavai1 == 0) return;
00927 
00928   while (tavai1 <= 0.0) {
00929     // must eliminate a particle from the forward side
00930     iskip = G4int(G4UniformRand()*iavai1) + 1; 
00931     is = 0;  
00932     for (i = vecLen-1; i >= 0; i--) {
00933       if (pv[i].getSide() > 0) {
00934         if (++is == iskip) {
00935           tavai1 += pv[i].getMass();
00936           iavai1--;            
00937           if (i != vecLen-1) { 
00938             for (j = i; j < vecLen; j++) pv[j] = pv[j+1];
00939           }
00940           if (--vecLen == 0) return;  // all the secondaries except the
00941           break;                 // --+
00942         }                        //   |
00943       }                          //   v
00944     }                            // break goes down to here
00945   }                              // to the end of the for- loop.                          
00946 
00947   tavai2 = (targ+1)*centerOfMassEnergy/2.;
00948   G4int iavai2 = 0;
00949 
00950      for (i = 0; i < vecLen; i++)
00951          {
00952            if (pv[i].getSide() < 0)
00953               {
00954                  tavai2 -= pv[i].getMass();
00955                  iavai2++;
00956               }
00957          }
00958      if (iavai2 == 0) return;
00959 
00960      while( tavai2 <= 0.0 ) 
00961         {             // must eliminate a particle from the backward side
00962            iskip = G4int(G4UniformRand()*iavai2) + 1; 
00963            is = 0;
00964            for( i = vecLen-1; i >= 0; i-- ) 
00965               {
00966                 if( pv[i].getSide() < 0 ) 
00967                   {
00968                     if( ++is == iskip ) 
00969                        {
00970                          tavai2 += pv[i].getMass();
00971                          iavai2--;
00972                          if (pv[i].getSide() == -2) ntarg--;
00973                          if (i != vecLen-1)
00974                             {
00975                               for( j=i; j<vecLen; j++)
00976                                  { 
00977                                    pv[j] = pv[j+1];
00978                                  } 
00979                             }
00980                          if (--vecLen == 0) return;
00981                          break;     
00982                        }
00983                   }   
00984               }
00985         }
00986 
00987   if (verboseLevel > 1) {
00988     G4cout << " pv Vector after Energy checks "
00989            << vecLen << " " << tavai1 << " " << iavai1 << " " << tavai2
00990            << " " <<  iavai2 << " " << ntarg << G4endl;
00991     pvI.Print(-1);
00992     pvT.Print(-1);
00993     for (i=0; i < vecLen ; i++) pv[i].Print(i);
00994   } 
00995    
00996   //  define some vectors for Lorentz transformations
00997    
00998   G4HEVector* pvmx = new G4HEVector [10];
00999    
01000   pvmx[0].setMass( incidentMass );
01001   pvmx[0].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
01002   pvmx[1].setMass( protonMass);
01003   pvmx[1].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
01004   pvmx[3].setMass( protonMass*(1+targ));
01005   pvmx[3].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
01006   pvmx[4].setZero();
01007   pvmx[5].setZero();
01008   pvmx[7].setZero();
01009   pvmx[8].setZero();
01010   pvmx[8].setMomentum( 1.0, 0.0 );
01011   pvmx[2].Add( pvmx[0], pvmx[1] );
01012   pvmx[3].Add( pvmx[3], pvmx[0] );
01013   pvmx[0].Lor( pvmx[0], pvmx[2] );
01014   pvmx[1].Lor( pvmx[1], pvmx[2] );
01015 
01016   if (verboseLevel > 1) {
01017     G4cout << " General Vectors after Definition " << G4endl;
01018     for (i=0; i<10; i++) pvmx[i].Print(i);
01019   }
01020 
01021   // Main loop for 4-momentum generation - see Pitha-report (Aachen) 
01022   // for a detailed description of the method.
01023   // Process the secondary particles in reverse order.
01024 
01025   G4double dndl[20];
01026   G4double binl[20];
01027   G4double pvMass(0), pvEnergy(0);
01028   G4int pvCode; 
01029   G4double aspar, pt, phi, et, xval;
01030   G4double ekin  = 0.;
01031   G4double ekin1 = 0.;
01032   G4double ekin2 = 0.;
01033   G4int npg   = 0;
01034   G4double rmg0 = 0.;
01035   G4int targ1 = 0;                // No fragmentation model for nucleons from
01036   phi = G4UniformRand()*twopi;
01037 
01038   for (i = vecLen-1; i >= 0; i--) {
01039         // Intranuclear cascade: mark them with -3 and leave the loop
01040         if( i == 1)
01041           {
01042             if ( (pv[i].getMass() > neutronMass + 0.05) && (G4UniformRand() < 0.2))
01043                { 
01044                  if(++npg < 19)
01045                    {
01046                      pv[i].setSide(-3);
01047                      rmg0 += pv[i].getMass();
01048                      targ++;
01049                      continue;
01050                    }
01051                }
01052             else if ( pv[i].getMass() > protonMass - 0.05)
01053                {
01054                  if(++npg < 19)
01055                    {
01056                      pv[i].setSide(-3);
01057                      rmg0 += pv[i].getMass();
01058                      targ++;
01059                      continue;
01060                    }
01061                }  
01062           }  
01063         if( pv[i].getSide() == -2) 
01064           { 
01065             if ( pv[i].getName() == "Proton" || pv[i].getName() == "Neutron")
01066                {                                 
01067                  if( ++npg < 19 ) 
01068                    {
01069                      pv[i].setSide( -3 );
01070                      rmg0 += pv[i].getMass(); 
01071                      targ1++;
01072                      continue;                // leave the for loop !!
01073                    }     
01074                }
01075           }
01076          // Set pt and phi values - they are changed somewhat in the  
01077          // iteration loop.
01078          // Set mass parameter for lambda fragmentation model
01079 
01080         G4double maspar[] = { 0.75, 0.70, 0.65, 0.60, 0.50, 0.40, 0.20, 0.10};
01081         G4double     bp[] = { 4.00, 2.50, 2.20, 3.00, 3.00, 1.70, 3.50, 3.50};
01082         G4double   ptex[] = { 1.70, 1.70, 1.50, 1.70, 1.40, 1.20, 1.70, 1.20};    
01083 
01084         // Set parameters for lambda simulation 
01085         // pt is the average transverse momentum
01086         // aspar is average transverse mass
01087   
01088         pvMass = pv[i].getMass();       
01089         j = 2;                                              
01090         if (pv[i].getType() == mesonType ) j = 1;
01091         if ( pv[i].getMass() < 0.4 ) j = 0;
01092         if ( i <= 1 ) j += 3;
01093         if (pv[i].getSide() <= -2) j = 6;
01094         if (j == 6 && (pv[i].getType() == baryonType || pv[i].getType() == antiBaryonType)) j = 7;
01095         pt    = std::sqrt(std::pow(-std::log(1.-G4UniformRand())/bp[j],ptex[j]));
01096         if(pt<0.05) pt = Amax(0.001, 0.3*G4UniformRand());
01097         aspar = maspar[j]; 
01098         phi = G4UniformRand()*twopi;
01099         pv[i].setMomentum( pt*std::cos(phi), pt*std::sin(phi) );  // set x- and y-momentum
01100 
01101         for( j=0; j<20; j++ ) binl[j] = j/(19.*pt);  // set the lambda - bins.
01102      
01103         if( pv[i].getSide() > 0 )
01104            et = pvmx[0].getEnergy();
01105         else
01106            et = pvmx[1].getEnergy();
01107      
01108         dndl[0] = 0.0;
01109      
01110         // Start of outer iteration loop
01111 
01112         G4int outerCounter = 0, innerCounter = 0;        // three times.
01113         G4bool eliminateThisParticle = true;
01114         G4bool resetEnergies = true;
01115         while( ++outerCounter < 3 ) 
01116              {
01117                for( l=1; l<20; l++ ) 
01118                   {
01119                     xval  = (binl[l]+binl[l-1])/2.;      // x = lambda /GeV 
01120                     if( xval > 1./pt )
01121                        dndl[l] = dndl[l-1];
01122                     else
01123                        dndl[l] = dndl[l-1] + 
01124                          aspar/std::sqrt( std::pow((1.+aspar*xval*aspar*xval),3) ) *
01125                          (binl[l]-binl[l-1]) * et / 
01126                          std::sqrt( pt*xval*et*pt*xval*et + pt*pt + pvMass*pvMass );
01127                   }  
01128        
01129                // Start of inner iteration loop
01130 
01131                innerCounter = 0;          // try this not more than 7 times. 
01132                while( ++innerCounter < 7 ) 
01133                     {
01134                       l = 1;
01135                       ran = G4UniformRand()*dndl[19];
01136                       while( ( ran >= dndl[l] ) && ( l < 20 ) )l++;
01137                       l = Imin( 19, l );
01138                       xval = Amin( 1.0, pt*(binl[l-1] + G4UniformRand()*(binl[l]-binl[l-1]) ) );
01139                       if( pv[i].getSide() < 0 ) xval *= -1.;
01140                       pv[i].setMomentumAndUpdate( xval*et );  // Set the z-momentum
01141                       pvEnergy = pv[i].getEnergy();
01142                       if( pv[i].getSide() > 0 )               // Forward side 
01143                         {
01144                           if ( i < 2 )
01145                              { 
01146                                ekin = tavai1 - ekin1;
01147                                if (ekin < 0.) ekin = 0.04*std::fabs(normal());
01148                                G4double pp1 = pv[i].Length();
01149                                if (pp1 >= 1.e-6)
01150                                   {
01151                                     G4double pp = std::sqrt(ekin*(ekin+2*pvMass));
01152                                     pp = Amax(0., pp*pp - pt*pt);
01153                                     pp = std::sqrt(pp)*pv[i].getSide()/std::fabs(G4double(pv[i].getSide())); // cast for aCC 
01154                                     pv[i].setMomentumAndUpdate( pp );
01155                                   }
01156                                else
01157                                   {
01158                                     pv[i].setMomentum(0.,0.,0.); 
01159                                     pv[i].setKineticEnergyAndUpdate( ekin);
01160                                   }
01161                                pvmx[4].Add( pvmx[4], pv[i]);
01162                                outerCounter = 2;
01163                                resetEnergies = false;
01164                                eliminateThisParticle = false; 
01165                                break;
01166                              }      
01167                           else if( (ekin1+pvEnergy-pvMass) < 0.95*tavai1 ) 
01168                             {
01169                               pvmx[4].Add( pvmx[4], pv[i] );
01170                               ekin1 += pvEnergy - pvMass;
01171                               pvmx[6].Add( pvmx[4], pvmx[5] );
01172                               pvmx[6].setMomentum( 0.0 );
01173                               outerCounter = 2;            // leave outer loop
01174                               eliminateThisParticle = false;        // don't eliminate this particle
01175                               resetEnergies = false;
01176                               break;                       // next particle
01177                             }
01178                           if( innerCounter > 5 ) break;    // leave inner loop
01179                           
01180                           if( tavai2 >= pvMass ) 
01181                             {                              // switch sides
01182                               pv[i].setSide( -1 );
01183                               tavai1 += pvMass;
01184                               tavai2 -= pvMass;
01185                               iavai2++;
01186                             }
01187                         } 
01188                       else 
01189                         {                                  // backward side
01190                           xval = Amin(0.999,0.95+0.05*targ/20.0);
01191                           if( (ekin2+pvEnergy-pvMass) < xval*tavai2 ) 
01192                             {
01193                               pvmx[5].Add( pvmx[5], pv[i] );
01194                               ekin2 += pvEnergy - pvMass;
01195                               pvmx[6].Add( pvmx[4], pvmx[5] );
01196                               pvmx[6].setMomentum( 0.0 );    // set z-momentum
01197                               outerCounter = 2;       // leave outer iteration
01198                               eliminateThisParticle = false;       // don't eliminate this particle
01199                               resetEnergies = false;
01200                               break;                   // leave inner iteration
01201                             }
01202                           if( innerCounter > 5 )break; // leave inner iteration
01203                           
01204                           if( tavai1 >= pvMass ) 
01205                             {                          // switch sides
01206                               pv[i].setSide( 1 );
01207                               tavai1  -= pvMass;
01208                               tavai2  += pvMass;
01209                               iavai2--;
01210                             }
01211                         }
01212                       pv[i].setMomentum( pv[i].getMomentum().x() * 0.9,
01213                                          pv[i].getMomentum().y() * 0.9);
01214                       pt *= 0.9;
01215                       dndl[19] *= 0.9;
01216                     }                                 // closes inner loop
01217 
01218                if (resetEnergies)
01219                     {
01220                       if (verboseLevel > 1) {
01221                         G4cout << " Reset energies for index " << i << " " 
01222                                << ekin1 << " " << tavai1 << G4endl;
01223                         pv[i].Print(i);
01224                       }
01225                       ekin1 = 0.0;
01226                       ekin2 = 0.0;
01227                       pvmx[4].setZero();
01228                       pvmx[5].setZero();
01229 
01230                       for( l=i+1; l < vecLen; l++ ) 
01231                          {
01232                            if( (pv[l].getMass() < protonMass) || (pv[l].getSide() > 0) ) 
01233                              {
01234                                 pvEnergy = pv[l].getMass() + 0.95*pv[l].getKineticEnergy(); 
01235                                 pv[l].setEnergyAndUpdate( pvEnergy );
01236                                 if( pv[l].getSide() > 0) 
01237                                   {
01238                                     ekin1 += pv[l].getKineticEnergy();
01239                                     pvmx[4].Add( pvmx[4], pv[l] );
01240                                   } 
01241                                 else 
01242                                   {
01243                                     ekin2 += pv[l].getKineticEnergy();
01244                                     pvmx[5].Add( pvmx[5], pv[l] );
01245                                   }
01246                              }
01247                          }
01248                     }
01249              }                                  // closes outer iteration
01250 
01251     if (eliminateThisParticle) {
01252       // Not enough energy - eliminate this particle
01253       if (verboseLevel > 1) {
01254         G4cout << " Eliminate particle index " << i << G4endl;
01255         pv[i].Print(i);
01256       }
01257       if (i != vecLen-1) {
01258         // shift down
01259         for (j = i; j < vecLen-1; j++) pv[j] = pv[j+1];
01260       }
01261       vecLen--;
01262 
01263       if (vecLen < 2) {
01264         delete [] pvmx;
01265         return;
01266       }
01267       i++;
01268       pvmx[6].Add( pvmx[4], pvmx[5] );
01269       pvmx[6].setMomentum( 0.0 );          // set z-momentum
01270     }
01271   }                                   // closes main for loop
01272 
01273   if (verboseLevel > 1) {
01274     G4cout << " pv Vector after lambda fragmentation " << vecLen << G4endl;
01275     pvI.Print(-1);
01276     pvT.Print(-1);
01277     for (i=0; i < vecLen ; i++) pv[i].Print(i);
01278     for (i=0; i < 10; i++) pvmx[i].Print(i);
01279   } 
01280 
01281   // Backward nucleons produced with a cluster model
01282 
01283   G4double gpar[] = {2.6, 2.6, 1.80, 1.30, 1.20};
01284   G4double cpar[] = {0.6, 0.6, 0.35, 0.15, 0.10};
01285  
01286   if (npg > 0) {
01287     G4double rmg = rmg0;
01288     if (npg > 1) {
01289       G4int npg1 = npg-1;
01290       if (npg1 >4) npg1 = 4;
01291       rmg += std::pow( -std::log(1.-G4UniformRand()), cpar[npg1])/gpar[npg1];
01292     }
01293     G4double ga = 1.2;
01294     G4double ekit1 = 0.04, ekit2 = 0.6;
01295     if (incidentKineticEnergy < 5.) {
01296       ekit1 *= sqr(incidentKineticEnergy)/25.;
01297       ekit2 *= sqr(incidentKineticEnergy)/25.;
01298     }
01299     G4double avalue = (1.-ga)/(std::pow(ekit2,1.-ga)-std::pow(ekit1,1.-ga));
01300     for (i = 0; i < vecLen; i++) {
01301       if (pv[i].getSide() == -3) {
01302         G4double ekit = std::pow(G4UniformRand()*(1.-ga)/avalue + std::pow(ekit1,1.-ga), 1./(1.-ga) );
01303         G4double cost = Amax(-1., Amin(1., std::log(2.23*G4UniformRand()+0.383)/0.96));
01304         G4double sint = std::sqrt(1. - cost*cost);
01305         G4double pphi  = twopi*G4UniformRand();
01306         G4double pp   = std::sqrt(ekit*(ekit+2*pv[i].getMass()));
01307         pv[i].setMomentum(pp*sint*std::sin(pphi),
01308                           pp*sint*std::cos(pphi),
01309                           pp*cost);
01310         pv[i].Lor( pv[i], pvmx[2] );
01311         pvmx[5].Add( pvmx[5], pv[i] );
01312       }
01313     } 
01314   }
01315         
01316   if (vecLen <= 2) {
01317     successful = false;
01318     delete [] pvmx;
01319     return;
01320   }  
01321 
01322   // Lorentz transformation in lab system
01323 
01324    targ = 0;
01325    for( i=0; i < vecLen; i++ ) 
01326       {
01327         if( pv[i].getType() == baryonType )targ++;
01328         if( pv[i].getType() == antiBaryonType )targ--;
01329         if(verboseLevel > 1) pv[i].Print(i); 
01330         pv[i].Lor( pv[i], pvmx[1] );
01331         if(verboseLevel > 1) pv[i].Print(i);
01332       }
01333    if ( targ <1) targ = 1;
01334 
01335    G4bool dum=0;
01336    if( lead ) 
01337      {
01338        for( i=0; i<vecLen; i++ ) 
01339           {
01340             if( pv[i].getCode() == lead ) 
01341               {
01342                 dum = false;
01343                 break;
01344               }
01345           }
01346        if( dum ) 
01347          {
01348            i = 0;          
01349  
01350            if(   (    (leadParticle.getType() == baryonType ||
01351                        leadParticle.getType() == antiBaryonType)
01352                    && (pv[1].getType() == baryonType ||
01353                        pv[1].getType() == antiBaryonType))
01354               || (    (leadParticle.getType() == mesonType)
01355                    && (pv[1].getType() == mesonType)))
01356              {
01357                i = 1;
01358              } 
01359             ekin = pv[i].getKineticEnergy();
01360             pv[i] = leadParticle;  
01361             if( pv[i].getFlag() )
01362                 pv[i].setTOF( -1.0 );
01363             else
01364                 pv[i].setTOF( 1.0 );
01365             pv[i].setKineticEnergyAndUpdate( ekin );
01366          }
01367      }
01368 
01369   pvmx[3].setMass( incidentMass);
01370   pvmx[3].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
01371    
01372   G4double ekin0 = pvmx[3].getKineticEnergy();
01373    
01374   pvmx[4].setMass( protonMass * targ);
01375   pvmx[4].setEnergy( protonMass * targ);
01376   pvmx[4].setKineticEnergy(0.);
01377   pvmx[4].setMomentum(0., 0., 0.);
01378   ekin = pvmx[3].getEnergy() + pvmx[4].getEnergy();
01379 
01380    pvmx[5].Add( pvmx[3], pvmx[4] );
01381    pvmx[3].Lor( pvmx[3], pvmx[5] );
01382    pvmx[4].Lor( pvmx[4], pvmx[5] );
01383    
01384    G4double tecm = pvmx[3].getEnergy() + pvmx[4].getEnergy();
01385 
01386    pvmx[7].setZero();
01387    
01388    ekin1 = 0.0;   
01389    G4double teta, wgt; 
01390    
01391    for( i=0; i < vecLen; i++ ) 
01392       {
01393         pvmx[7].Add( pvmx[7], pv[i] );
01394         ekin1 += pv[i].getKineticEnergy();
01395         ekin  -= pv[i].getMass();
01396       }
01397    
01398    if( vecLen > 1 && vecLen < 19 ) 
01399      {
01400        G4bool constantCrossSection = true;
01401        G4HEVector pw[19];
01402        for(i=0; i<vecLen; i++) pw[i] = pv[i]; 
01403        wgt = NBodyPhaseSpace( tecm, constantCrossSection, pw, vecLen );
01404        ekin = 0.0;
01405        for( i=0; i < vecLen; i++ ) 
01406           {
01407             pvmx[6].setMass( pw[i].getMass());
01408             pvmx[6].setMomentum( pw[i].getMomentum() );
01409             pvmx[6].SmulAndUpdate( pvmx[6], 1. );
01410             pvmx[6].Lor( pvmx[6], pvmx[4] );
01411             ekin += pvmx[6].getKineticEnergy();
01412           }
01413        teta = pvmx[7].Ang( pvmx[3] );
01414        if (verboseLevel > 1)
01415          G4cout << " vecLen > 1 && vecLen < 19 " << teta << " " << ekin0 
01416                 << " " << ekin1 << " " << ekin << G4endl;
01417      }
01418 
01419    if( ekin1 != 0.0 ) 
01420      {
01421        pvmx[6].setZero();
01422        wgt = ekin/ekin1;
01423        ekin1 = 0.;
01424        for( i=0; i < vecLen; i++ ) 
01425           {
01426             pvMass = pv[i].getMass();
01427             ekin   = pv[i].getKineticEnergy() * wgt;
01428             pv[i].setKineticEnergyAndUpdate( ekin );
01429             ekin1 += ekin;
01430             pvmx[6].Add( pvmx[6], pv[i] );
01431           }
01432        teta = pvmx[6].Ang( pvmx[3] );
01433        if (verboseLevel > 1) {
01434          G4cout << " ekin1 != 0 " << teta << " " <<  ekin0 << " " 
01435                 <<  ekin1 << G4endl;
01436          incidentParticle.Print(0);
01437          targetParticle.Print(1);
01438          for(i=0;i<vecLen;i++) pv[i].Print(i);
01439        }
01440      }
01441 
01442   // Do some smearing in the transverse direction due to Fermi motion
01443    
01444    G4double ry   = G4UniformRand();
01445    G4double rz   = G4UniformRand();
01446    G4double rx   = twopi*rz;
01447    G4double a1   = std::sqrt(-2.0*std::log(ry));
01448    G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
01449    G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
01450                                                   
01451    for (i = 0; i < vecLen; i++) 
01452      pv[i].setMomentum( pv[i].getMomentum().x()+rantarg1,
01453                         pv[i].getMomentum().y()+rantarg2 );
01454 
01455    if (verboseLevel > 1) {
01456      pvmx[6].setZero();
01457      for (i = 0; i < vecLen; i++) pvmx[6].Add( pvmx[6], pv[i] );
01458      teta = pvmx[6].Ang( pvmx[3] );   
01459      G4cout << " After smearing " << teta << G4endl;
01460    }
01461 
01462   // Rotate in the direction of the primary particle momentum (z-axis).
01463   // This does disturb our inclusive distributions somewhat, but it is 
01464   // necessary for momentum conservation
01465 
01466   // Also subtract binding energies and make some further corrections 
01467   // if required
01468 
01469   G4double dekin = 0.0;
01470   G4int npions = 0;    
01471   G4double ek1 = 0.0;
01472   G4double alekw, xxh;
01473   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
01474   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
01475   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70};
01476    
01477   if (verboseLevel > 1)
01478     G4cout << " Rotation in Direction  of primary particle (Defs1)" << G4endl;
01479 
01480   for (i = 0; i < vecLen; i++) { 
01481     if(verboseLevel > 1) pv[i].Print(i);
01482     pv[i].Defs1( pv[i], pvI );
01483     if(verboseLevel > 1) pv[i].Print(i);
01484     if (atomicWeight > 1.5) {
01485       ekin = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
01486       alekw = std::log( incidentKineticEnergy );
01487       xxh = 1.;
01488       if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
01489         if (pv[i].getCode() == pionZeroCode) {
01490           if (G4UniformRand() < std::log(atomicWeight)) { 
01491             if (alekw > alem[0]) {
01492               G4int jmax = 1;
01493               for (j = 1; j < 8; j++) {
01494                 if (alekw < alem[j]) {
01495                   jmax = j;
01496                   break;
01497                 }
01498               }
01499               xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
01500                    + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
01501               xxh = 1. - xxh;
01502             }
01503           }      
01504         }
01505       }
01506       dekin += ekin*(1.-xxh);
01507       ekin *= xxh;
01508       pv[i].setKineticEnergyAndUpdate( ekin );
01509       pvCode = pv[i].getCode();
01510       if ((pvCode == pionPlusCode) ||
01511           (pvCode == pionMinusCode) ||
01512           (pvCode == pionZeroCode)) {
01513         npions += 1;
01514         ek1 += ekin; 
01515       }
01516     }
01517   }
01518 
01519   if ( (ek1 > 0.0) && (npions > 0) ) {
01520     dekin = 1.+dekin/ek1;
01521     for (i = 0; i < vecLen; i++) {
01522       pvCode = pv[i].getCode();
01523       if ((pvCode == pionPlusCode) ||
01524           (pvCode == pionMinusCode) ||
01525           (pvCode == pionZeroCode)) {
01526         ekin = Amax(1.0e-6, pv[i].getKineticEnergy() * dekin);
01527         pv[i].setKineticEnergyAndUpdate( ekin );
01528       }
01529     }
01530   }
01531 
01532   if (verboseLevel > 1) {
01533     G4cout << " Lab-System " <<  ek1 << " " << npions << G4endl;
01534     incidentParticle.Print(0);
01535     targetParticle.Print(1);
01536     for (i = 0; i < vecLen; i++) pv[i].Print(i);
01537   }
01538 
01539   // Add black track particles
01540   // the total number of particles produced is restricted to 198
01541   // this may have influence on very high energies
01542 
01543    if (verboseLevel > 1) 
01544       G4cout << " Evaporation : " <<  atomicWeight << " " 
01545              << excitationEnergyGNP << " " <<  excitationEnergyDTA << G4endl;
01546 
01547    G4double sprob = 0.;
01548    if (incidentKineticEnergy > 5.)
01549 //       sprob = Amin(1., (0.394-0.063*std::log(atomicWeight))*std::log(incidentKineticEnergy-4.) );
01550      sprob = Amin(1., 0.000314*atomicWeight*std::log(incidentKineticEnergy-4.)); 
01551      if( atomicWeight > 1.5 && G4UniformRand() > sprob ) 
01552      {
01553 
01554        G4double cost, sint, pp, eka;
01555        G4int spall(0), nbl(0);
01556 
01557        // first add protons and neutrons
01558 
01559        if( excitationEnergyGNP >= 0.001 ) 
01560          {
01561            //  nbl = number of proton/neutron black track particles
01562            //  tex is their total kinetic energy (GeV)
01563        
01564            nbl = Poisson( (1.5+1.25*targ)*excitationEnergyGNP/
01565                                          (excitationEnergyGNP+excitationEnergyDTA));
01566            if( targ+nbl > atomicWeight ) nbl = (int)(atomicWeight - targ);
01567            if (verboseLevel > 1) 
01568               G4cout << " evaporation " << targ << " " << nbl << " " 
01569                      << sprob << G4endl; 
01570            spall = targ;
01571            if( nbl > 0) 
01572              {
01573                ekin = (excitationEnergyGNP)/nbl;
01574                ekin2 = 0.0;
01575                for( i=0; i<nbl; i++ ) 
01576                   {
01577                     if( G4UniformRand() < sprob ) 
01578                       {
01579                         if(verboseLevel > 1) G4cout << " Particle skipped " << G4endl;
01580                         continue;
01581                       }
01582                     if( ekin2 > excitationEnergyGNP) break;
01583                     ran = G4UniformRand();
01584                     ekin1 = -ekin*std::log(ran) - cfa*(1.0+0.5*normal());
01585                     if (ekin1 < 0) ekin1 = -0.010*std::log(ran);
01586                     ekin2 += ekin1;
01587                     if( ekin2 > excitationEnergyGNP)
01588                     ekin1 = Amax( 1.0e-6, excitationEnergyGNP-(ekin2-ekin1) );
01589                     if( G4UniformRand() > (1.0-atomicNumber/(atomicWeight)))
01590                        pv[vecLen] = Proton;
01591                     else
01592                        pv[vecLen] = Neutron;
01593                     spall++;
01594                     cost = G4UniformRand() * 2.0 - 1.0;
01595                     sint = std::sqrt(std::fabs(1.0-cost*cost));
01596                     phi = twopi * G4UniformRand();
01597                     pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
01598                     pv[vecLen].setSide( -4 );
01599                     pv[vecLen].setTOF( 1.0 );
01600                     pvMass = pv[vecLen].getMass();
01601                     pvEnergy = ekin1 + pvMass;
01602                     pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
01603                     pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
01604                                                      pp*sint*std::cos(phi),
01605                                                      pp*cost );
01606                     if (verboseLevel > 1) pv[vecLen].Print(vecLen);
01607                     vecLen++;
01608                   }
01609                if( (atomicWeight >= 10.0 ) && (incidentKineticEnergy <= 2.0) ) 
01610                   {
01611                     G4int ika, kk = 0;
01612                     eka = incidentKineticEnergy;
01613                     if( eka > 1.0 )eka *= eka;
01614                     eka = Amax( 0.1, eka );
01615                     ika = G4int(3.6*std::exp((atomicNumber*atomicNumber
01616                                 /atomicWeight-35.56)/6.45)/eka);
01617                     if( ika > 0 ) 
01618                       {
01619                         for( i=(vecLen-1); i>=0; i-- ) 
01620                            {
01621                              if( (pv[i].getCode() == protonCode) && pv[i].getFlag() ) 
01622                                {
01623                                  pTemp = pv[i];
01624                                  pv[i].setDefinition("Neutron");
01625                                  pv[i].setMomentumAndUpdate(pTemp.getMomentum());
01626                                  if (verboseLevel > 1) pv[i].Print(i);
01627                                  if( ++kk > ika ) break;
01628                                }
01629                            }
01630                       }
01631                   }
01632              }
01633          }
01634 
01635      // finished adding proton/neutron black track particles
01636      // now, try to add deuterons, tritons and alphas
01637      
01638      if( excitationEnergyDTA >= 0.001 ) 
01639        {
01640          nbl = Poisson( (1.5+1.25*targ)*excitationEnergyDTA
01641                                       /(excitationEnergyGNP+excitationEnergyDTA));
01642        
01643          // nbl is the number of deutrons, tritons, and alphas produced
01644 
01645          if (verboseLevel > 1) 
01646             G4cout << " evaporation " << targ << " " << nbl << " " 
01647                    << sprob << G4endl;        
01648          if( nbl > 0 ) 
01649            {
01650              ekin = excitationEnergyDTA/nbl;
01651              ekin2 = 0.0;
01652              for( i=0; i<nbl; i++ ) 
01653                 {
01654                   if( G4UniformRand() < sprob ) 
01655                     {
01656                       if(verboseLevel > 1) G4cout << " Particle skipped " << G4endl;
01657                       continue;
01658                     } 
01659                   if( ekin2 > excitationEnergyDTA) break;
01660                   ran = G4UniformRand();
01661                   ekin1 = -ekin*std::log(ran)-cfa*(1.+0.5*normal());
01662                   if( ekin1 < 0.0 ) ekin1 = -0.010*std::log(ran);
01663                   ekin2 += ekin1;
01664                   if( ekin2 > excitationEnergyDTA)
01665                      ekin1 = Amax( 1.0e-6, excitationEnergyDTA-(ekin2-ekin1));
01666                   cost = G4UniformRand()*2.0 - 1.0;
01667                   sint = std::sqrt(std::fabs(1.0-cost*cost));
01668                   phi = twopi*G4UniformRand();
01669                   ran = G4UniformRand();
01670                   if( ran <= 0.60 ) 
01671                       pv[vecLen] = Deuteron;
01672                   else if (ran <= 0.90)
01673                       pv[vecLen] = Triton;
01674                   else
01675                       pv[vecLen] = Alpha;
01676                   spall += (int)(pv[vecLen].getMass() * 1.066);
01677                   if( spall > atomicWeight ) break;
01678                   pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
01679                   pv[vecLen].setSide( -4 );
01680                   pvMass = pv[vecLen].getMass();
01681                   pv[vecLen].setTOF( 1.0 );
01682                   pvEnergy = pvMass + ekin1;
01683                   pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
01684                   pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
01685                                                    pp*sint*std::cos(phi),
01686                                                    pp*cost );
01687                   if (verboseLevel > 1) pv[vecLen].Print(vecLen);
01688                   vecLen++;
01689                 }
01690             }
01691         }
01692     }
01693    if( centerOfMassEnergy <= (4.0+G4UniformRand()) ) 
01694      {
01695        for( i=0; i<vecLen; i++ ) 
01696          {
01697            G4double etb = pv[i].getKineticEnergy();
01698            if( etb >= incidentKineticEnergy ) 
01699               pv[i].setKineticEnergyAndUpdate( incidentKineticEnergy );
01700          }
01701      }
01702 
01703    if(verboseLevel > 1)
01704      { G4cout << "Call TuningOfHighEnergyCacsading vecLen = " << vecLen << G4endl;
01705        incidentParticle.Print(0);
01706        targetParticle.Print(1);
01707        for (i=0; i<vecLen; i++) pv[i].Print(i);
01708      } 
01709 
01710    TuningOfHighEnergyCascading( pv, vecLen, 
01711                                 incidentParticle, targetParticle, 
01712                                 atomicWeight, atomicNumber);
01713 
01714    if(verboseLevel > 1)
01715      { G4cout << " After Tuning: " << G4endl;
01716        for(i=0; i<vecLen; i++) pv[i].Print(i);
01717      }
01718 
01719    // Calculate time delay for nuclear reactions
01720 
01721    G4double tof = incidentTOF;
01722    if(     (atomicWeight >= 1.5) && (atomicWeight <= 230.0) 
01723         && (incidentKineticEnergy <= 0.2) )
01724            tof -= 500.0 * std::exp(-incidentKineticEnergy /0.04) * std::log( G4UniformRand() );
01725 
01726    for(i=0; i<vecLen; i++)
01727    {
01728      if(pv[i].getName() == "KaonZero" || pv[i].getName() == "AntiKaonZero")
01729      {
01730        pvmx[0] = pv[i];
01731        if(G4UniformRand() < 0.5) pv[i].setDefinition("KaonZeroShort");
01732        else                    pv[i].setDefinition("KaonZeroLong");
01733        pv[i].setMomentumAndUpdate(pvmx[0].getMomentum());
01734      }
01735    } 
01736 
01737    successful = true;
01738    delete [] pvmx;
01739    G4int testCurr=0;
01740    G4double totKin=0;
01741    for(testCurr=0; testCurr<vecLen; testCurr++)
01742    {
01743       totKin+=pv[testCurr].getKineticEnergy();
01744       if(totKin>incidentKineticEnergy*1.05)
01745       {
01746         vecLen = testCurr;
01747         break;
01748       }
01749    }
01750    
01751   return;
01752 }

void G4HEInelastic::HighEnergyClusterProduction ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
G4double excitationEnergyGNP,
G4double excitationEnergyDTA,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 2097 of file G4HEInelastic.cc.

References G4HEVector::Add(), Amax(), Amin(), G4HEVector::Ang(), AntiProton, DBL_MAX, Erlang(), G4cout, G4endl, G4UniformRand, GammaRand(), G4HEVector::getCode(), G4HEVector::getEnergy(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getTotalMomentum(), G4HEVector::getType(), Imin(), KaonPlus, G4HEVector::Length(), G4HEVector::Lor(), NBodyPhaseSpace(), Neutron, neutronCode, normal(), PionMinus, PionPlus, PionZero, Poisson(), G4InuclParticleNames::pp, G4HEVector::Print(), Proton, G4HEVector::setDefinition(), G4HEVector::setEnergy(), G4HEVector::setFlag(), G4HEVector::setKineticEnergy(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMass(), G4HEVector::setMomentum(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setSide(), G4HEVector::setTOF(), G4HEVector::setZero(), G4HEVector::Smul(), G4HEVector::SmulAndUpdate(), sqr(), TuningOfHighEnergyCascading(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

02106 {   
02107 // For low multiplicity in the first intranuclear interaction the cascading process
02108 // as described in G4HEInelastic::MediumEnergyCascading does not work 
02109 // satisfactorily. From experimental data it is strongly suggested to use 
02110 // a two- body resonance model.   
02111 //  
02112 //  All quantities on the G4HEVector Array pv are in GeV- units.
02113 
02114   G4int protonCode       = Proton.getCode();
02115   G4double protonMass    = Proton.getMass();
02116   G4int neutronCode      = Neutron.getCode();
02117   G4double kaonPlusMass  = KaonPlus.getMass();
02118   G4int pionPlusCode     = PionPlus.getCode();    
02119   G4int pionZeroCode     = PionZero.getCode();    
02120   G4int pionMinusCode    = PionMinus.getCode(); 
02121   G4String mesonType = PionPlus.getType();
02122   G4String baryonType = Proton.getType(); 
02123   G4String antiBaryonType = AntiProton.getType(); 
02124   
02125   G4double targetMass = targetParticle.getMass();
02126 
02127    G4int    incidentCode          = incidentParticle.getCode();
02128    G4double incidentMass          = incidentParticle.getMass();
02129    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
02130    G4double incidentEnergy        = incidentParticle.getEnergy();
02131    G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
02132    G4String incidentType          = incidentParticle.getType();
02133 //   G4double incidentTOF           = incidentParticle.getTOF();   
02134    G4double incidentTOF           = 0.;
02135    
02136   // some local variables
02137   G4int i, j;
02138    
02139   if (verboseLevel > 1)
02140     G4cout << " G4HEInelastic::HighEnergyClusterProduction " << G4endl;
02141 
02142   successful = false; 
02143   if (incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
02144 
02145   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
02146                                          +2.*targetMass*incidentEnergy);
02147 
02148   G4HEVector pvI = incidentParticle;  // for the incident particle
02149   pvI.setSide(1);
02150 
02151   G4HEVector pvT = targetParticle;   // for the target particle
02152   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
02153   pvT.setSide( -1 );
02154   pvT.setTOF( -1.); 
02155                     // distribute particles in forward and backward
02156                     // hemispheres. Note that only low multiplicity
02157                     // events from FirstIntInNuc.... should go into 
02158                     // this routine. 
02159   G4int targ  = 0;  
02160   G4int ifor  = 0; 
02161   G4int iback = 0;
02162   G4int pvCode;
02163   G4double pvMass, pvEnergy; 
02164 
02165   pv[0].setSide(1);
02166   pv[1].setSide(-1);
02167   for (i = 0; i < vecLen; i++) {
02168     if (i > 1) {
02169       if (G4UniformRand() < 0.5) {
02170         pv[i].setSide( 1 );
02171         if (++ifor > 18) { 
02172           pv[i].setSide(-1);
02173           ifor--;
02174           iback++;
02175         }
02176       } else {
02177         pv[i].setSide( -1 );
02178         if (++iback > 18) { 
02179           pv[i].setSide(1);
02180           ifor++;
02181           iback--;
02182         }
02183       }
02184     }
02185 
02186     pvCode = pv[i].getCode();
02187 
02188     if (   (    (incidentCode == protonCode) || (incidentCode == neutronCode)
02189              || (incidentType == mesonType) )
02190         && (    (pvCode == pionPlusCode) || (pvCode == pionMinusCode) )
02191         && (    (G4UniformRand() < (10.-incidentTotalMomentum)/6.) )
02192         && (    (G4UniformRand() < atomicWeight/300.) ) ) {
02193       if (G4UniformRand() > atomicNumber/atomicWeight) 
02194         pv[i].setDefinition("Neutron");
02195       else
02196         pv[i].setDefinition("Proton");
02197       targ++;
02198     }
02199     pv[i].setTOF( incidentTOF );                 
02200   }
02201    
02202   G4double tb = 2. * iback;
02203   if (centerOfMassEnergy < (2+G4UniformRand())) tb = (2.*iback + vecLen)/2.;
02204    
02205   G4double nucsup[] = {1.0, 0.7, 0.5, 0.4, 0.35, 0.3};
02206   G4double psup[] = {3. , 6. , 20., 50., 100.,1000.};   
02207   G4double ss = centerOfMassEnergy*centerOfMassEnergy;
02208 
02209   G4double xtarg = Amax(0.01, Amin(0.50, 0.312+0.2*std::log(std::log(ss))+std::pow(ss,1.5)/6000.) 
02210                              * (std::pow(atomicWeight,0.33)-1.) * tb);
02211   G4int momentumBin = 0;
02212    while( (momentumBin < 6) && (incidentTotalMomentum > psup[momentumBin])) momentumBin++;
02213    momentumBin = Imin(5, momentumBin);
02214    G4double xpnhmf = Amax(0.01,xtarg*nucsup[momentumBin]);
02215    G4double xshhmf = Amax(0.01,xtarg-xpnhmf);
02216    G4double rshhmf = 0.25*xshhmf;
02217    G4double rpnhmf = 0.81*xpnhmf;
02218    G4double xhmf;
02219    G4int nshhmf, npnhmf;
02220    if (rshhmf > 1.1)
02221      {
02222        rshhmf = xshhmf/(rshhmf-1.);
02223        if (rshhmf <= 20.)
02224          xhmf = GammaRand( rshhmf );
02225        else
02226          xhmf = Erlang( G4int(rshhmf+0.5) );
02227        xshhmf *= xhmf/rshhmf;
02228      }
02229    nshhmf = Poisson( xshhmf );
02230    if (rpnhmf > 1.1)
02231      {
02232        rpnhmf = xpnhmf/(rpnhmf -1.);
02233        if (rpnhmf <= 20.)
02234          xhmf = GammaRand( rpnhmf );
02235        else
02236          xhmf = Erlang( G4int(rpnhmf+0.5) );
02237        xpnhmf *= xhmf/rpnhmf;
02238      }
02239    npnhmf = Poisson( xpnhmf );
02240 
02241    while (npnhmf > 0)
02242      {
02243        if ( G4UniformRand() > (1. - atomicNumber/atomicWeight))
02244           pv[vecLen].setDefinition( "Proton" );
02245        else
02246           pv[vecLen].setDefinition( "Neutron" );
02247        targ++;
02248        pv[vecLen].setSide( -2 );
02249        pv[vecLen].setFlag( true );
02250        pv[vecLen].setTOF( incidentTOF );
02251        vecLen++;
02252        npnhmf--;
02253      }
02254    while (nshhmf > 0)
02255      {
02256        G4double ran = G4UniformRand();
02257        if (ran < 0.333333 )
02258           pv[vecLen].setDefinition( "PionPlus" );
02259        else if (ran < 0.6667)
02260           pv[vecLen].setDefinition( "PionZero" );
02261        else
02262           pv[vecLen].setDefinition( "PionMinus" );
02263        pv[vecLen].setSide( -2 );
02264        pv[vecLen].setFlag( true );
02265        pv[vecLen].setTOF( incidentTOF );
02266        vecLen++;
02267        nshhmf--;
02268      }    
02269 
02270    // Mark leading particles for incident strange particles 
02271    // and antibaryons, for all other we assume that the first 
02272    // and second particle are the leading particles. 
02273    // We need this later for kinematic aspects of strangeness conservation.
02274                           
02275    G4int lead = 0;                   
02276    G4HEVector leadParticle;
02277    if( (incidentMass >= kaonPlusMass-0.05) && (incidentCode != protonCode)  
02278                                            && (incidentCode != neutronCode) ) 
02279          {       
02280            G4double pMass = pv[0].getMass();
02281            G4int    pCode = pv[0].getCode();
02282            if( (pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
02283                                             && (pCode != neutronCode) ) 
02284                   {       
02285                     lead = pCode; 
02286                     leadParticle = pv[0];                           
02287                   } 
02288            else   
02289                   {
02290                     pMass = pv[1].getMass();
02291                     pCode = pv[1].getCode();
02292                     if( (pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
02293                                                      && (pCode != neutronCode) ) 
02294                         {       
02295                           lead = pCode;
02296                           leadParticle = pv[1];
02297                         }
02298                   }
02299          }
02300 
02301    if (verboseLevel > 1)
02302       { G4cout << " pv Vector after initialization " << vecLen << G4endl;
02303         pvI.Print(-1);
02304         pvT.Print(-1);
02305         for (i=0; i < vecLen ; i++) pv[i].Print(i);
02306       }     
02307 
02308    G4double tavai = 0.;
02309    for(i=0;i<vecLen;i++) if(pv[i].getSide() != -2) tavai  += pv[i].getMass();
02310 
02311    while (tavai > centerOfMassEnergy)
02312       {
02313          for (i=vecLen-1; i >= 0; i--)
02314             {
02315               if (pv[i].getSide() != -2)
02316                  {
02317                     tavai -= pv[i].getMass();
02318                     if( i != vecLen-1) 
02319                       {
02320                         for (j=i; j < vecLen; j++)
02321                            {
02322                               pv[j]  = pv[j+1];
02323                            }
02324                       }
02325                     if ( --vecLen < 2)
02326                       {
02327                         successful = false;
02328                         return;
02329                       }
02330                     break;
02331                  }
02332             }    
02333       }
02334 
02335    // Now produce 3 Clusters:
02336    // 1. forward cluster
02337    // 2. backward meson cluster
02338    // 3. backward nucleon cluster
02339 
02340    G4double rmc0 = 0., rmd0 = 0., rme0 = 0.;
02341    G4int    ntc  = 0,  ntd  = 0,  nte  = 0;
02342    
02343    for (i=0; i < vecLen; i++)
02344       {
02345         if(pv[i].getSide() > 0)
02346            {
02347              if(ntc < 17)
02348                { 
02349                  rmc0 += pv[i].getMass();
02350                  ntc++;
02351                }
02352              else
02353                {
02354                  if(ntd < 17)
02355                    {
02356                      pv[i].setSide(-1);
02357                      rmd0 += pv[i].getMass();
02358                      ntd++;
02359                    }
02360                  else
02361                    {
02362                      pv[i].setSide(-2);
02363                      rme0 += pv[i].getMass();
02364                      nte++;
02365                    }
02366                }
02367            }  
02368         else if (pv[i].getSide() == -1)
02369            {
02370              if(ntd < 17)
02371                 {
02372                    rmd0 += pv[i].getMass();
02373                    ntd++;
02374                 }
02375              else
02376                 {
02377                    pv[i].setSide(-2); 
02378                    rme0 += pv[i].getMass();
02379                    nte++;
02380                 }           
02381            }
02382         else
02383            {
02384              rme0 += pv[i].getMass();
02385              nte++;
02386            } 
02387       }         
02388 
02389    G4double cpar[] = {0.6, 0.6, 0.35, 0.15, 0.10};
02390    G4double gpar[] = {2.6, 2.6, 1.80, 1.30, 1.20};
02391     
02392    G4double rmc = rmc0, rmd = rmd0, rme = rme0; 
02393    G4int ntc1 = Imin(4,ntc-1);
02394    G4int ntd1 = Imin(4,ntd-1);
02395    G4int nte1 = Imin(4,nte-1);
02396    if (ntc > 1) rmc = rmc0 + std::pow(-std::log(1.-G4UniformRand()),cpar[ntc1])/gpar[ntc1];
02397    if (ntd > 1) rmd = rmd0 + std::pow(-std::log(1.-G4UniformRand()),cpar[ntd1])/gpar[ntd1];
02398    if (nte > 1) rme = rme0 + std::pow(-std::log(1.-G4UniformRand()),cpar[nte1])/gpar[nte1];
02399    while( (rmc+rmd) > centerOfMassEnergy)
02400       {
02401         if ((rmc == rmc0) && (rmd == rmd0))
02402           { 
02403             rmd *= 0.999*centerOfMassEnergy/(rmc+rmd);
02404             rmc *= 0.999*centerOfMassEnergy/(rmc+rmd);
02405           }
02406         else
02407           {
02408             rmc = 0.1*rmc0 + 0.9*rmc;
02409             rmd = 0.1*rmd0 + 0.9*rmd;
02410           }   
02411       }             
02412    if(verboseLevel > 1) 
02413      G4cout << " Cluster Masses: " << ntc << " " << rmc << " " << ntd
02414             << " " << rmd << " " << nte << " " << rme << G4endl;
02415  
02416    G4HEVector* pvmx = new G4HEVector[11];
02417 
02418    pvmx[1].setMass( incidentMass);
02419    pvmx[1].setMomentumAndUpdate( 0., 0., incidentTotalMomentum);
02420    pvmx[2].setMass( targetMass);
02421    pvmx[2].setMomentumAndUpdate( 0., 0., 0.);
02422    pvmx[0].Add( pvmx[1], pvmx[2] );
02423    pvmx[1].Lor( pvmx[1], pvmx[0] );
02424    pvmx[2].Lor( pvmx[2], pvmx[0] );
02425 
02426    G4double pf = std::sqrt(Amax(0.0001,  sqr(sqr(centerOfMassEnergy) + rmd*rmd -rmc*rmc)
02427                                  - 4*sqr(centerOfMassEnergy)*rmd*rmd))/(2.*centerOfMassEnergy);
02428    pvmx[3].setMass( rmc );
02429    pvmx[4].setMass( rmd );
02430    pvmx[3].setEnergy( std::sqrt(pf*pf + rmc*rmc) );
02431    pvmx[4].setEnergy( std::sqrt(pf*pf + rmd*rmd) );
02432    
02433    G4double tvalue = -DBL_MAX;
02434    G4double bvalue = Amax(0.01, 4.0 + 1.6*std::log(incidentTotalMomentum));
02435    if (bvalue != 0.0) tvalue = std::log(G4UniformRand())/bvalue;
02436    G4double pin = pvmx[1].Length();
02437    G4double tacmin = sqr( pvmx[1].getEnergy() - pvmx[3].getEnergy()) - sqr( pin - pf);
02438    G4double ctet   = Amax(-1., Amin(1., 1.+2.*(tvalue-tacmin)/Amax(1.e-10, 4.*pin*pf)));
02439    G4double stet   = std::sqrt(Amax(0., 1.0 - ctet*ctet));
02440    G4double phi    = twopi * G4UniformRand();
02441    pvmx[3].setMomentum( pf * stet * std::sin(phi), 
02442                         pf * stet * std::cos(phi),
02443                         pf * ctet           );
02444    pvmx[4].Smul( pvmx[3], -1.);
02445    
02446    if (nte > 0)
02447       {
02448         G4double ekit1 = 0.04;
02449         G4double ekit2 = 0.6;
02450         G4double gaval = 1.2;
02451         if (incidentKineticEnergy <= 5.)
02452            {
02453              ekit1 *= sqr(incidentKineticEnergy)/25.;
02454              ekit2 *= sqr(incidentKineticEnergy)/25.;
02455            }
02456         G4double avalue = (1.-gaval)/(std::pow(ekit2, 1.-gaval)-std::pow(ekit1, 1.-gaval));
02457         for (i=0; i < vecLen; i++)
02458             {
02459               if (pv[i].getSide() == -2)
02460                  {
02461                    G4double ekit = std::pow(G4UniformRand()*(1.-gaval)/avalue +std::pow(ekit1, 1.-gaval),
02462                                        1./(1.-gaval));
02463                    pv[i].setKineticEnergyAndUpdate( ekit );
02464                    ctet = Amax(-1., Amin(1., std::log(2.23*G4UniformRand()+0.383)/0.96));
02465                    stet = std::sqrt( Amax( 0.0, 1. - ctet*ctet ));
02466                    phi  = G4UniformRand()*twopi;
02467                    G4double pp = pv[i].Length();
02468                    pv[i].setMomentum( pp * stet * std::sin(phi),
02469                                       pp * stet * std::cos(phi),
02470                                       pp * ctet           );
02471                    pv[i].Lor( pv[i], pvmx[0] );
02472                  }              
02473             }             
02474       }
02475 //   pvmx[1] = pvmx[3];
02476 //   pvmx[2] = pvmx[4];
02477    pvmx[5].SmulAndUpdate( pvmx[3], -1.);
02478    pvmx[6].SmulAndUpdate( pvmx[4], -1.);
02479 
02480    if (verboseLevel > 1) { 
02481      G4cout << " General vectors before Phase space Generation " << G4endl;
02482      for (i=0; i<7; i++) pvmx[i].Print(i);
02483    }  
02484 
02485    G4HEVector* tempV = new G4HEVector[18];
02486    G4bool constantCrossSection = true;
02487    G4double wgt;
02488    G4int npg;
02489 
02490    if (ntc > 1)
02491       {
02492         npg = 0;
02493         for (i=0; i < vecLen; i++)
02494             {
02495               if (pv[i].getSide() > 0)
02496                  {
02497                    tempV[npg++] = pv[i];
02498                  }
02499             }
02500         wgt = NBodyPhaseSpace( pvmx[3].getMass(), constantCrossSection, tempV, npg);
02501                      
02502         npg = 0;
02503         for (i=0; i < vecLen; i++)
02504             {
02505               if (pv[i].getSide() > 0)
02506                  {
02507                    pv[i].setMomentum( tempV[npg++].getMomentum());
02508                    pv[i].SmulAndUpdate( pv[i], 1. );
02509                    pv[i].Lor( pv[i], pvmx[5] );
02510                  }
02511             }
02512       }
02513    else if(ntc == 1)
02514       {
02515         for(i=0; i<vecLen; i++)
02516           {
02517             if(pv[i].getSide() > 0) pv[i].setMomentumAndUpdate(pvmx[3].getMomentum());
02518           }
02519       }
02520    else
02521       {
02522       }
02523      
02524    if (ntd > 1)
02525       {
02526         npg = 0;
02527         for (i=0; i < vecLen; i++)
02528             {
02529               if (pv[i].getSide() == -1)
02530                  {
02531                    tempV[npg++] = pv[i];
02532                  }
02533             }
02534         wgt = NBodyPhaseSpace( pvmx[4].getMass(), constantCrossSection, tempV, npg);
02535                      
02536         npg = 0;
02537         for (i=0; i < vecLen; i++)
02538             {
02539               if (pv[i].getSide() == -1)
02540                  {
02541                    pv[i].setMomentum( tempV[npg++].getMomentum());
02542                    pv[i].SmulAndUpdate( pv[i], 1.);
02543                    pv[i].Lor( pv[i], pvmx[6] );
02544                  }
02545             }
02546       }
02547    else if(ntd == 1)
02548       {
02549         for(i=0; i<vecLen; i++)
02550           {
02551             if(pv[i].getSide() == -1) pv[i].setMomentumAndUpdate(pvmx[4].getMomentum());
02552           }
02553       }
02554    else
02555       {
02556       }
02557 
02558    if(verboseLevel > 1)
02559      {
02560        G4cout << " Vectors after PhaseSpace generation " << G4endl;
02561        for(i=0; i<vecLen; i++) pv[i].Print(i);
02562      }
02563 
02564    // Lorentz transformation in lab system
02565 
02566    targ = 0;
02567    for( i=0; i < vecLen; i++ ) 
02568       {
02569         if( pv[i].getType() == baryonType )targ++;
02570         if( pv[i].getType() == antiBaryonType )targ--;
02571         pv[i].Lor( pv[i], pvmx[2] );
02572       }
02573    if (targ<1) targ = 1;
02574 
02575    if(verboseLevel > 1) {
02576      G4cout << " Transformation in Lab- System " << G4endl;
02577      for(i=0; i<vecLen; i++) pv[i].Print(i);
02578    }
02579 
02580    G4bool dum(0);
02581    G4double ekin, teta;
02582 
02583    if( lead ) 
02584      {
02585        for( i=0; i<vecLen; i++ ) 
02586           {
02587             if( pv[i].getCode() == lead ) 
02588               {
02589                 dum = false;
02590                 break;
02591               }
02592           }
02593        if( dum ) 
02594          {
02595            i = 0;          
02596  
02597            if(   (    (leadParticle.getType() == baryonType ||
02598                        leadParticle.getType() == antiBaryonType)
02599                    && (pv[1].getType() == baryonType ||
02600                        pv[1].getType() == antiBaryonType))
02601               || (    (leadParticle.getType() == mesonType)
02602                    && (pv[1].getType() == mesonType)))
02603              {
02604                i = 1;
02605              } 
02606 
02607             ekin = pv[i].getKineticEnergy();
02608             pv[i] = leadParticle;
02609             if( pv[i].getFlag() )
02610                 pv[i].setTOF( -1.0 );
02611             else
02612                 pv[i].setTOF( 1.0 );
02613             pv[i].setKineticEnergyAndUpdate( ekin );
02614          }
02615      }
02616 
02617    pvmx[4].setMass( incidentMass);
02618    pvmx[4].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
02619    
02620    G4double ekin0 = pvmx[4].getKineticEnergy();
02621    
02622    pvmx[5].setMass ( protonMass * targ);
02623    pvmx[5].setEnergy( protonMass * targ);
02624    pvmx[5].setKineticEnergy(0.);
02625    pvmx[5].setMomentum( 0.0, 0.0, 0.0 );
02626 
02627    ekin = pvmx[4].getEnergy() + pvmx[5].getEnergy();
02628 
02629    pvmx[6].Add( pvmx[4], pvmx[5] );
02630    pvmx[4].Lor( pvmx[4], pvmx[6] );
02631    pvmx[5].Lor( pvmx[5], pvmx[6] );
02632    
02633    G4double tecm = pvmx[4].getEnergy() + pvmx[5].getEnergy();
02634 
02635    pvmx[8].setZero();
02636    
02637    G4double ekin1 = 0.0;   
02638    
02639    for( i=0; i < vecLen; i++ ) 
02640       {
02641         pvmx[8].Add( pvmx[8], pv[i] );
02642         ekin1 += pv[i].getKineticEnergy();
02643         ekin  -= pv[i].getMass();
02644       }
02645    
02646    if( vecLen > 1 && vecLen < 19 ) 
02647      {
02648        constantCrossSection = true;
02649        G4HEVector pw[18];
02650        for(i=0;i<vecLen;i++) pw[i] = pv[i];
02651        wgt = NBodyPhaseSpace( tecm, constantCrossSection, pw, vecLen );
02652        ekin = 0.0;
02653        for( i=0; i < vecLen; i++ ) 
02654           {
02655             pvmx[7].setMass( pw[i].getMass());
02656             pvmx[7].setMomentum( pw[i].getMomentum() );
02657             pvmx[7].SmulAndUpdate( pvmx[7], 1.);
02658             pvmx[7].Lor( pvmx[7], pvmx[5] );
02659             ekin += pvmx[7].getKineticEnergy();
02660           }
02661        teta = pvmx[8].Ang( pvmx[4] );
02662        if (verboseLevel > 1) 
02663          G4cout << " vecLen > 1 && vecLen < 19 " << teta << " " 
02664                 << ekin0 << " " << ekin1 << " " << ekin << G4endl;
02665      }
02666 
02667    if( ekin1 != 0.0 ) 
02668      {
02669        pvmx[7].setZero();
02670        wgt = ekin/ekin1;
02671        ekin1 = 0.;
02672        for( i=0; i < vecLen; i++ ) 
02673           {
02674             pvMass = pv[i].getMass();
02675             ekin   = pv[i].getKineticEnergy() * wgt;
02676             pv[i].setKineticEnergyAndUpdate( ekin );
02677             ekin1 += ekin;
02678             pvmx[7].Add( pvmx[7], pv[i] );
02679           }
02680        teta = pvmx[7].Ang( pvmx[4] );
02681        if (verboseLevel > 1) 
02682          G4cout << " ekin1 != 0 " << teta << " " << ekin0 << " " 
02683                 << ekin1 << G4endl;
02684      }
02685 
02686    if(verboseLevel > 1)
02687      {
02688        G4cout << " After energy- correction " << G4endl;
02689        for(i=0; i<vecLen; i++) pv[i].Print(i);
02690      }      
02691 
02692   // Do some smearing in the transverse direction due to Fermi motion
02693    
02694   G4double ry   = G4UniformRand();
02695   G4double rz   = G4UniformRand();
02696   G4double rx   = twopi*rz;
02697   G4double a1   = std::sqrt(-2.0*std::log(ry));
02698   G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
02699   G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
02700 
02701   for (i = 0; i < vecLen; i++)
02702     pv[i].setMomentum(pv[i].getMomentum().x()+rantarg1,
02703                       pv[i].getMomentum().y()+rantarg2);
02704 
02705   if (verboseLevel > 1) {
02706     pvmx[7].setZero();
02707     for (i = 0; i < vecLen; i++) pvmx[7].Add( pvmx[7], pv[i] );  
02708     teta = pvmx[7].Ang( pvmx[4] );   
02709     G4cout << " After smearing " << teta << G4endl;
02710   }
02711 
02712   // Rotate in the direction of the primary particle momentum (z-axis).
02713   // This does disturb our inclusive distributions somewhat, but it is 
02714   // necessary for momentum conservation
02715 
02716   // Also subtract binding energies and make some further corrections 
02717   // if required
02718 
02719   G4double dekin = 0.0;
02720   G4int npions = 0;    
02721   G4double ek1 = 0.0;
02722   G4double alekw, xxh;
02723   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
02724   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.0};
02725   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65, 0.70};
02726    
02727   for (i = 0; i < vecLen; i++) { 
02728     pv[i].Defs1( pv[i], pvI );
02729     if (atomicWeight > 1.5) {
02730       ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
02731       alekw = std::log( incidentKineticEnergy );
02732       xxh   = 1.;
02733       if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
02734         if (pv[i].getCode() == pionZeroCode) {
02735           if (G4UniformRand() < std::log(atomicWeight)) { 
02736             if (alekw > alem[0]) {
02737               G4int jmax = 1;
02738               for (j = 1; j < 8; j++) {
02739                 if (alekw < alem[j]) {
02740                   jmax = j;
02741                   break;
02742                 }
02743               } 
02744               xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
02745                      + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
02746               xxh = 1. - xxh;
02747             }
02748           }
02749         }
02750       }
02751       dekin += ekin*(1.-xxh);
02752       ekin *= xxh;
02753       pv[i].setKineticEnergyAndUpdate( ekin );
02754       pvCode = pv[i].getCode();
02755       if ((pvCode == pionPlusCode) ||
02756           (pvCode == pionMinusCode) ||
02757           (pvCode == pionZeroCode)) {
02758         npions += 1;
02759         ek1 += ekin; 
02760       }
02761     }
02762   }
02763 
02764    if( (ek1 > 0.0) && (npions > 0) ) 
02765       {
02766         dekin = 1.+dekin/ek1;
02767         for (i = 0; i < vecLen; i++)
02768           {
02769             pvCode = pv[i].getCode();
02770             if((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode)) 
02771               {
02772                 ekin = Amax( 1.0e-6, pv[i].getKineticEnergy() * dekin );
02773                 pv[i].setKineticEnergyAndUpdate( ekin );
02774               }
02775           }
02776       }
02777    if (verboseLevel > 1)
02778       { G4cout << " Lab-System " << ek1 << " " << npions << G4endl;
02779         for (i=0; i<vecLen; i++) pv[i].Print(i);
02780       }
02781 
02782    // Add black track particles
02783    // The total number of particles produced is restricted to 198
02784    // - this may have influence on very high energies
02785 
02786    if (verboseLevel > 1) 
02787        G4cout << " Evaporation " << atomicWeight << " " << excitationEnergyGNP
02788             << " " << excitationEnergyDTA << G4endl;
02789 
02790    G4double sprob = 0.;
02791    if (incidentKineticEnergy > 5. )
02792 //       sprob = Amin( 1., (0.394-0.063*std::log(atomicWeight))*std::log(incidentKineticEnergy-4.) );
02793      sprob = Amin(1., 0.000314*atomicWeight*std::log(incidentKineticEnergy-4.)); 
02794      if( atomicWeight > 1.5 && G4UniformRand() > sprob) 
02795      {
02796 
02797        G4double cost, sint, ekin2, ran, pp, eka;
02798        G4int spall(0), nbl(0);
02799 
02800        //  first add protons and neutrons
02801 
02802        if( excitationEnergyGNP >= 0.001 ) 
02803          {
02804            //  nbl = number of proton/neutron black track particles
02805            //  tex is their total kinetic energy (GeV)
02806        
02807            nbl = Poisson( (1.5+1.25*targ)*excitationEnergyGNP/
02808                                          (excitationEnergyGNP+excitationEnergyDTA));
02809            if( targ+nbl > atomicWeight ) nbl = (int)(atomicWeight - targ);
02810            if (verboseLevel > 1) 
02811               G4cout << " evaporation " << targ << " " << nbl << " " 
02812                      << sprob << G4endl; 
02813            spall = targ;
02814            if( nbl > 0) 
02815              {
02816                ekin = excitationEnergyGNP/nbl;
02817                ekin2 = 0.0;
02818                for( i=0; i<nbl; i++ ) 
02819                   {
02820                     if( G4UniformRand() < sprob ) continue;
02821                     if( ekin2 > excitationEnergyGNP) break;
02822                     ran = G4UniformRand();
02823                     ekin1 = -ekin*std::log(ran) - cfa*(1.0+0.5*normal());
02824                     if (ekin1 < 0) ekin1 = -0.010*std::log(ran);
02825                     ekin2 += ekin1;
02826                     if( ekin2 > excitationEnergyGNP)
02827                     ekin1 = Amax( 1.0e-6, excitationEnergyGNP-(ekin2-ekin1) );
02828                     if( G4UniformRand() > (1.0-atomicNumber/(atomicWeight)))
02829                        pv[vecLen].setDefinition( "Proton");
02830                     else
02831                        pv[vecLen].setDefinition( "Neutron" );
02832                     spall++;
02833                     cost = G4UniformRand() * 2.0 - 1.0;
02834                     sint = std::sqrt(std::fabs(1.0-cost*cost));
02835                     phi = twopi * G4UniformRand();
02836                     pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
02837                     pv[vecLen].setSide( -4 );
02838                     pvMass = pv[vecLen].getMass();
02839                     pv[vecLen].setTOF( 1.0 );
02840                     pvEnergy = ekin1 + pvMass;
02841                     pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
02842                     pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
02843                                                      pp*sint*std::cos(phi),
02844                                                      pp*cost );
02845                     if (verboseLevel > 1) pv[vecLen].Print(vecLen);
02846                     vecLen++;
02847                   }
02848                if( (atomicWeight >= 10.0 ) && (incidentKineticEnergy <= 2.0) ) 
02849                   {
02850                     G4int ika, kk = 0;
02851                     eka = incidentKineticEnergy;
02852                     if( eka > 1.0 )eka *= eka;
02853                     eka = Amax( 0.1, eka );
02854                     ika = G4int(3.6*std::exp((atomicNumber*atomicNumber
02855                                 /atomicWeight-35.56)/6.45)/eka);
02856                     if( ika > 0 ) 
02857                       {
02858                         for( i=(vecLen-1); i>=0; i-- ) 
02859                            {
02860                              if( (pv[i].getCode() == protonCode) && pv[i].getFlag() ) 
02861                                {
02862                                  G4HEVector pTemp = pv[i];
02863                                  pv[i].setDefinition( "Neutron" );
02864                                  pv[i].setMomentumAndUpdate(pTemp.getMomentum());
02865                                  if (verboseLevel > 1) pv[i].Print(i);
02866                                  if( ++kk > ika ) break;
02867                                }
02868                            }
02869                       }
02870                   }
02871              }
02872          }
02873 
02874      // Finished adding proton/neutron black track particles
02875      // now, try to add deuterons, tritons and alphas
02876      
02877      if( excitationEnergyDTA >= 0.001 ) 
02878        {
02879          nbl = Poisson( (1.5+1.25*targ)*excitationEnergyDTA
02880                                       /(excitationEnergyGNP+excitationEnergyDTA));
02881        
02882          //    nbl is the number of deutrons, tritons, and alphas produced
02883        
02884          if( nbl > 0 ) 
02885            {
02886              ekin = excitationEnergyDTA/nbl;
02887              ekin2 = 0.0;
02888              for( i=0; i<nbl; i++ ) 
02889                 {
02890                   if( G4UniformRand() < sprob ) continue;
02891                   if( ekin2 > excitationEnergyDTA) break;
02892                   ran = G4UniformRand();
02893                   ekin1 = -ekin*std::log(ran)-cfa*(1.+0.5*normal());
02894                   if( ekin1 < 0.0 ) ekin1 = -0.010*std::log(ran);
02895                   ekin2 += ekin1;
02896                   if( ekin2 > excitationEnergyDTA )
02897                      ekin1 = Amax( 1.0e-6, excitationEnergyDTA-(ekin2-ekin1));
02898                   cost = G4UniformRand()*2.0 - 1.0;
02899                   sint = std::sqrt(std::fabs(1.0-cost*cost));
02900                   phi = twopi*G4UniformRand();
02901                   ran = G4UniformRand();
02902                   if( ran <= 0.60 ) 
02903                       pv[vecLen].setDefinition( "Deuteron");
02904                   else if (ran <= 0.90)
02905                       pv[vecLen].setDefinition( "Triton" );
02906                   else
02907                       pv[vecLen].setDefinition( "Alpha" );
02908                   spall += (int)(pv[vecLen].getMass() * 1.066);
02909                   if( spall > atomicWeight ) break;
02910                   pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
02911                   pv[vecLen].setSide( -4 );
02912                   pvMass = pv[vecLen].getMass();
02913                   pv[vecLen].setTOF( 1.0 );
02914                   pvEnergy = pvMass + ekin1;
02915                   pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
02916                   pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
02917                                                    pp*sint*std::cos(phi),
02918                                                    pp*cost );
02919                   if (verboseLevel > 1) pv[vecLen].Print(vecLen);
02920                   vecLen++;
02921                 }
02922             }
02923         }
02924     }
02925    if( centerOfMassEnergy <= (4.0+G4UniformRand()) ) 
02926      {
02927        for( i=0; i<vecLen; i++ ) 
02928          {
02929            G4double etb = pv[i].getKineticEnergy();
02930            if( etb >= incidentKineticEnergy ) 
02931               pv[i].setKineticEnergyAndUpdate( incidentKineticEnergy );
02932          }
02933      }
02934 
02935    TuningOfHighEnergyCascading( pv, vecLen,
02936                                 incidentParticle, targetParticle,
02937                                 atomicWeight, atomicNumber);    
02938 
02939    // Calculate time delay for nuclear reactions
02940 
02941    G4double tof = incidentTOF;
02942    if(     (atomicWeight >= 1.5) && (atomicWeight <= 230.0) 
02943         && (incidentKineticEnergy <= 0.2) )
02944            tof -= 500.0 * std::exp(-incidentKineticEnergy /0.04) * std::log( G4UniformRand() );
02945    for ( i=0; i < vecLen; i++)     
02946      { 
02947        
02948        pv[i].setTOF ( tof );
02949 //       vec[i].SetTOF ( tof );
02950      }
02951 
02952    for(i=0; i<vecLen; i++)
02953    {
02954      if(pv[i].getName() == "KaonZero" || pv[i].getName() == "AntiKaonZero")
02955      {
02956        pvmx[0] = pv[i];
02957        if(G4UniformRand() < 0.5) pv[i].setDefinition("KaonZeroShort");
02958        else                    pv[i].setDefinition("KaonZeroLong");
02959        pv[i].setMomentumAndUpdate(pvmx[0].getMomentum());
02960      }
02961    } 
02962 
02963   successful = true;
02964   delete [] pvmx;
02965   delete [] tempV;
02966   return;
02967 }

G4int G4HEInelastic::Imax ( G4int  a,
G4int  b 
)

Definition at line 140 of file G4HEInelastic.cc.

Referenced by G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), and MediumEnergyCascading().

00141   {
00142     G4int c = a;
00143     if(b > a) c = b;
00144     return c;
00145   } 

G4int G4HEInelastic::Imin ( G4int  a,
G4int  b 
)

Definition at line 133 of file G4HEInelastic.cc.

Referenced by G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), and MediumEnergyClusterProduction().

00134   {
00135     G4int c = a;
00136     if(b < a) c = b;
00137     return c;
00138   } 

void G4HEInelastic::MediumEnergyCascading ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
G4double excitationEnergyGNP,
G4double excitationEnergyDTA,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 2970 of file G4HEInelastic.cc.

References G4HEVector::Add(), Amax(), Amin(), G4HEVector::Ang(), AntiKaonZero, AntiProton, G4cout, G4endl, G4UniformRand, G4HEVector::getCode(), G4HEVector::getEnergy(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getMomentum(), G4HEVector::getSide(), G4HEVector::getTotalMomentum(), G4HEVector::getType(), Imax(), Imin(), KaonMinus, KaonPlus, KaonZero, KaonZeroLong, KaonZeroShort, G4HEVector::Length(), G4HEVector::Lor(), NBodyPhaseSpace(), Neutron, neutronCode, normal(), NuclearExcitation(), PionMinus, PionPlus, PionZero, Poisson(), G4InuclParticleNames::pp, G4HEVector::Print(), Proton, G4HEVector::setDefinition(), G4HEVector::setEnergy(), G4HEVector::setEnergyAndUpdate(), G4HEVector::setFlag(), G4HEVector::setKineticEnergy(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMass(), G4HEVector::setMomentum(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setSide(), G4HEVector::setTOF(), G4HEVector::setZero(), G4HEVector::Smul(), G4HEVector::SmulAndUpdate(), sqr(), G4HEVector::Sub(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

02979 {
02980   // The multiplicity of particles produced in the first interaction has been
02981   // calculated in one of the FirstIntInNuc.... routines. The nuclear
02982   // cascading particles are parametrized from experimental data.
02983   // A simple single variable description E D3S/DP3= F(Q) with
02984   // Q^2 = (M*X)^2 + PT^2 is used. Final state kinematic is produced
02985   // by an FF-type iterative cascade method.
02986   // Nuclear evaporation particles are added at the end of the routine.
02987 
02988   // All quantities on the G4HEVector Array pv are in GeV- units.
02989 
02990   G4int protonCode       = Proton.getCode();
02991   G4double protonMass    = Proton.getMass();
02992   G4int neutronCode      = Neutron.getCode();
02993   G4double kaonPlusMass  = KaonPlus.getMass();
02994   G4int kaonPlusCode     = KaonPlus.getCode();   
02995   G4int kaonMinusCode    = KaonMinus.getCode();
02996   G4int kaonZeroSCode    = KaonZeroShort.getCode(); 
02997   G4int kaonZeroLCode    = KaonZeroLong.getCode();
02998   G4int kaonZeroCode     = KaonZero.getCode();
02999   G4int antiKaonZeroCode = AntiKaonZero.getCode(); 
03000   G4int pionPlusCode     = PionPlus.getCode();    
03001   G4int pionZeroCode     = PionZero.getCode();    
03002   G4int pionMinusCode = PionMinus.getCode(); 
03003   G4String mesonType = PionPlus.getType();
03004   G4String baryonType = Proton.getType(); 
03005   G4String antiBaryonType = AntiProton.getType(); 
03006 
03007   G4double targetMass = targetParticle.getMass();
03008 
03009   G4int incidentCode = incidentParticle.getCode();
03010   G4double incidentMass = incidentParticle.getMass();
03011   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
03012   G4double incidentEnergy = incidentParticle.getEnergy();
03013   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
03014   G4String incidentType = incidentParticle.getType();
03015 //  G4double incidentTOF           = incidentParticle.getTOF();   
03016   G4double incidentTOF = 0.;
03017    
03018   // some local variables
03019 
03020   G4int i, j, l;
03021 
03022   if(verboseLevel > 1) 
03023      G4cout << " G4HEInelastic::MediumEnergyCascading " << G4endl;
03024 
03025   // define annihilation channels.
03026                                  
03027   G4bool annihilation = false;
03028   if (incidentCode < 0 && incidentType == antiBaryonType && 
03029       pv[0].getType() != antiBaryonType &&
03030       pv[1].getType() != antiBaryonType) { 
03031     annihilation = true;
03032   }
03033  
03034   successful = false; 
03035 
03036   G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
03037    
03038    if(annihilation) goto start;
03039    if(vecLen >= 8) goto start;
03040    if(incidentKineticEnergy < 1.) return;
03041    if(    (   incidentCode == kaonPlusCode  || incidentCode == kaonMinusCode
03042            || incidentCode == kaonZeroCode  || incidentCode == antiKaonZeroCode
03043            || incidentCode == kaonZeroSCode || incidentCode == kaonZeroLCode )
03044        && ( G4UniformRand() < 0.5)) goto start;
03045    if(G4UniformRand() > twsup[vecLen-1]) goto start;
03046    return;
03047 
03048    start:  
03049    
03050    if (annihilation)
03051       {            // do some corrections of incident particle kinematic
03052         G4double ekcor = Amax( 1., 1./incidentKineticEnergy);
03053         incidentKineticEnergy = 2*targetMass + incidentKineticEnergy*(1.+ekcor/atomicWeight);
03054         G4double excitation = NuclearExcitation(incidentKineticEnergy,
03055                                                 atomicWeight,
03056                                                 atomicNumber,
03057                                                 excitationEnergyGNP,
03058                                                 excitationEnergyDTA);
03059         incidentKineticEnergy -= excitation;
03060         if (incidentKineticEnergy < excitationEnergyDTA) incidentKineticEnergy = 0.;
03061         incidentEnergy = incidentKineticEnergy + incidentMass;
03062         incidentTotalMomentum =
03063                  std::sqrt( Amax(0., incidentEnergy*incidentEnergy - incidentMass*incidentMass));
03064       }  
03065                   
03066    G4HEVector pTemp;
03067    for(i = 2; i<vecLen; i++)
03068      {
03069        j = Imin(vecLen-1, (G4int)(2. + G4UniformRand()*(vecLen-2)));
03070        pTemp = pv[j];
03071        pv[j] = pv[i];
03072        pv[i] = pTemp;
03073      }
03074 
03075   // randomize the first two leading particles
03076   // for kaon induced reactions only 
03077   // (need from experimental data)
03078 
03079   if ((incidentCode==kaonPlusCode  || incidentCode==kaonMinusCode    ||
03080        incidentCode==kaonZeroCode  || incidentCode==antiKaonZeroCode ||
03081        incidentCode==kaonZeroSCode || incidentCode==kaonZeroLCode)   
03082       && (G4UniformRand()>0.7) ) {
03083     pTemp = pv[1];
03084     pv[1] = pv[0];
03085     pv[0] = pTemp;
03086   }
03087 
03088   // mark leading particles for incident strange particles 
03089   // and antibaryons, for all other we assume that the first 
03090   // and second particle are the leading particles. 
03091   // We need this later for kinematic aspects of strangeness
03092   // conservation.
03093                           
03094   G4int lead = 0;                   
03095   G4HEVector leadParticle;
03096   if ((incidentMass >= kaonPlusMass-0.05) && (incidentCode != protonCode)  
03097                                           && (incidentCode != neutronCode) ) {       
03098     G4double pMass = pv[0].getMass();
03099     G4int    pCode = pv[0].getCode();
03100     if ((pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
03101                                      && (pCode != neutronCode) ) {       
03102       lead = pCode; 
03103       leadParticle = pv[0];                           
03104     } else {
03105       pMass = pv[1].getMass();
03106       pCode = pv[1].getCode();
03107       if ((pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
03108                                        && (pCode != neutronCode) ) {       
03109         lead = pCode;
03110         leadParticle = pv[1];
03111       }
03112     }
03113   }
03114 
03115   // Distribute particles in forward and backward hemispheres in center of 
03116   // mass system.  Incident particle goes in forward hemisphere.
03117    
03118   G4HEVector pvI = incidentParticle;  // for the incident particle
03119   pvI.setSide( 1 );
03120 
03121   G4HEVector pvT = targetParticle;   // for the target particle
03122   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
03123   pvT.setSide( -1 );
03124   pvT.setTOF( -1.);  
03125 
03126   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass)+sqr(targetMass)
03127                                       +2.0*targetMass*incidentEnergy );
03128 
03129   G4double tavai1 = centerOfMassEnergy/2.0 - incidentMass;
03130   G4double tavai2 = centerOfMassEnergy/2.0 - targetMass;           
03131    
03132   G4int ntb = 1;
03133   for (i = 0; i < vecLen; i++) {
03134     if (i == 0) {
03135       pv[i].setSide(1);
03136     } else if (i == 1) {
03137       pv[i].setSide(-1);
03138     } else {
03139       if (G4UniformRand() < 0.5) {
03140         pv[i].setSide(-1);
03141         ntb++;
03142       } else pv[i].setSide(1);
03143     }
03144     pv[i].setTOF(incidentTOF);
03145   }
03146 
03147   G4double tb = 2. * ntb;
03148   if (centerOfMassEnergy < (2. + G4UniformRand())) 
03149        tb = (2. * ntb + vecLen)/2.;     
03150 
03151   if (verboseLevel > 1) {
03152     G4cout << " pv Vector after Randomization " << vecLen << G4endl;
03153     pvI.Print(-1);
03154     pvT.Print(-1);
03155     for (i=0; i < vecLen ; i++) pv[i].Print(i);
03156   } 
03157 
03158   // Add particles from intranuclear cascade
03159   // nuclearCascadeCount = number of new secondaries 
03160   // produced by nuclear cascading.
03161   //  extraCount = number of nucleons within these new secondaries
03162    
03163   G4double ss, xtarg, ran;
03164   ss = centerOfMassEnergy*centerOfMassEnergy;
03165   xtarg = Amax( 0.01, Amin( 0.75, 0.312 + 0.200 * std::log(std::log(ss)) 
03166                                  + std::pow(ss,1.5)/6000.0 ) 
03167                 *(std::pow(atomicWeight, 0.33) - 1.0) * tb);
03168 
03169   G4int ntarg = Poisson(xtarg);
03170   G4int targ = 0;
03171    
03172   if (ntarg > 0) {
03173        G4double nucsup[] = { 1.00, 0.7, 0.5, 0.4, 0.35,   0.3 };
03174        G4double psup[]   = {   3.,  6., 20., 50., 100., 1000. };
03175        G4int momentumBin = 0;
03176        while( (momentumBin < 6) && (incidentTotalMomentum > psup[momentumBin]) )
03177              momentumBin++;
03178        momentumBin = Imin( 5, momentumBin );
03179      
03180        // NOTE: in GENXPT, these new particles were given negative codes
03181        //       here I use  flag = true  instead
03182      
03183        for( i=0; i<ntarg; i++ ) 
03184         {
03185           if( G4UniformRand() < nucsup[momentumBin] ) 
03186             {
03187               if( G4UniformRand() > 1.0-atomicNumber/atomicWeight ) 
03188                   pv[vecLen].setDefinition( "Proton" );
03189               else 
03190                   pv[vecLen].setDefinition( "Neutron" );
03191               targ++;
03192             } 
03193           else 
03194             {
03195               ran = G4UniformRand();
03196               if( ran < 0.33333 ) 
03197                   pv[vecLen].setDefinition( "PionPlus");
03198               else if( ran < 0.66667 ) 
03199                   pv[vecLen].setDefinition( "PionZero");
03200               else 
03201                   pv[vecLen].setDefinition( "PionMinus" );
03202             }
03203           pv[vecLen].setSide( -2 );            // backward cascade particles
03204           pv[vecLen].setFlag( true );          // true is the same as IPA(i)<0
03205           pv[vecLen].setTOF( incidentTOF );
03206           vecLen++; 
03207         }
03208      }
03209                                          
03210    //  assume conservation of kinetic energy 
03211    //  in forward & backward hemispheres
03212 
03213    G4int is, iskip;
03214    tavai1 = centerOfMassEnergy/2.;
03215    G4int iavai1 = 0;
03216  
03217    for (i = 0; i < vecLen; i++) 
03218        { 
03219          if (pv[i].getSide() > 0)
03220             { 
03221                tavai1 -= pv[i].getMass();
03222                iavai1++;
03223             }    
03224        } 
03225    if ( iavai1 == 0) return;
03226 
03227    while( tavai1 <= 0.0 ) 
03228         {                // must eliminate a particle from the forward side
03229            iskip = G4int(G4UniformRand()*iavai1) + 1; 
03230            is = 0;  
03231            for( i=vecLen-1; i>=0; i-- ) 
03232               {
03233                 if( pv[i].getSide() > 0 ) 
03234                   {
03235                     if (++is == iskip) 
03236                         {
03237                            tavai1 += pv[i].getMass();
03238                            iavai1--;            
03239                            if ( i != vecLen-1)
03240                               { 
03241                                  for( j=i; j<vecLen; j++ ) 
03242                                     {         
03243                                        pv[j] = pv[j+1];
03244                                     }
03245                               }
03246                            if( --vecLen == 0 ) return;     // all the secondaries except of the 
03247                            break;            // --+
03248                         }                    //   |
03249                   }                          //   v
03250               }                              // break goes down to here
03251         }                                    // to the end of the for- loop.
03252                                        
03253 
03254      tavai2 = (targ+1)*centerOfMassEnergy/2.;
03255      G4int iavai2 = 0;
03256 
03257      for (i = 0; i < vecLen; i++)
03258          {
03259            if (pv[i].getSide() < 0)
03260               {
03261                  tavai2 -= pv[i].getMass();
03262                  iavai2++;
03263               }
03264          }
03265      if (iavai2 == 0) return;
03266 
03267      while( tavai2 <= 0.0 ) 
03268         {                 // must eliminate a particle from the backward side
03269            iskip = G4int(G4UniformRand()*iavai2) + 1; 
03270            is = 0;
03271            for( i = vecLen-1; i >= 0; i-- ) 
03272               {
03273                 if( pv[i].getSide() < 0 ) 
03274                   {
03275                     if( ++is == iskip ) 
03276                        {
03277                          tavai2 += pv[i].getMass();
03278                          iavai2--;
03279                          if (pv[i].getSide() == -2) ntarg--;
03280                          if (i != vecLen-1)
03281                             {
03282                               for( j=i; j<vecLen; j++)
03283                                  { 
03284                                    pv[j] = pv[j+1];
03285                                  } 
03286                             }
03287                          if (--vecLen == 0) return;
03288                          break;     
03289                        }
03290                   }   
03291               }
03292         }
03293 
03294      if (verboseLevel > 1) {
03295        G4cout << " pv Vector after Energy checks " << vecLen << " " 
03296               << tavai1 << " " << iavai1 << " " << tavai2 << " " 
03297               << iavai2 << " " << ntarg << G4endl;
03298        pvI.Print(-1);
03299        pvT.Print(-1);
03300        for (i=0; i < vecLen ; i++) pv[i].Print(i);
03301      } 
03302    
03303    // Define some vectors for Lorentz transformations
03304    
03305    G4HEVector* pvmx = new G4HEVector [10];
03306    
03307    pvmx[0].setMass( incidentMass );
03308    pvmx[0].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
03309    pvmx[1].setMass( protonMass);
03310    pvmx[1].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
03311    pvmx[3].setMass( protonMass*(1+targ));
03312    pvmx[3].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
03313    pvmx[4].setZero();
03314    pvmx[5].setZero();
03315    pvmx[7].setZero();
03316    pvmx[8].setZero();
03317    pvmx[8].setMomentum( 1.0, 0.0 );
03318    pvmx[2].Add( pvmx[0], pvmx[1] );
03319    pvmx[3].Add( pvmx[3], pvmx[0] );
03320    pvmx[0].Lor( pvmx[0], pvmx[2] );
03321    pvmx[1].Lor( pvmx[1], pvmx[2] );
03322 
03323    if (verboseLevel > 1) {
03324      G4cout << " General Vectors after Definition " << G4endl;
03325      for (i=0; i<10; i++) pvmx[i].Print(i);
03326    }
03327 
03328    // Main loop for 4-momentum generation - see Pitha-report (Aachen) 
03329    // for a detailed description of the method.
03330    // Process the secondary particles in reverse order
03331 
03332    G4double dndl[20];
03333    G4double binl[20];
03334    G4double pvMass, pvEnergy;
03335    G4int    pvCode; 
03336    G4double aspar, pt, phi, et, xval;
03337    G4double ekin  = 0.;
03338    G4double ekin1 = 0.;
03339    G4double ekin2 = 0.;
03340    phi = G4UniformRand()*twopi;
03341    G4int npg   = 0;
03342    G4int targ1 = 0;                // No fragmentation model for nucleons 
03343    for( i=vecLen-1; i>=0; i-- )    // from the intranuclear cascade. Mark
03344       {                            // them with -3 and leave the loop.
03345         if( (pv[i].getSide() == -2) || (i == 1) ) 
03346           { 
03347             if ( pv[i].getType() == baryonType ||
03348                  pv[i].getType() == antiBaryonType)
03349                {                                 
03350                  if( ++npg < 19 ) 
03351                    {
03352                      pv[i].setSide( -3 );
03353                      targ1++;
03354                      continue;                // leave the for loop !!
03355                    }     
03356                }
03357           }
03358 
03359         // Set pt and phi values - they are changed somewhat in the 
03360         // iteration loop.
03361         // Set mass parameter for lambda fragmentation model
03362 
03363         G4double maspar[] = { 0.75, 0.70, 0.65, 0.60, 0.50, 0.40, 0.75, 0.20};
03364         G4double     bp[] = { 3.50, 3.50, 3.50, 6.00, 5.00, 4.00, 3.50, 3.50};
03365         G4double   ptex[] = { 1.70, 1.70, 1.50, 1.70, 1.40, 1.20, 1.70, 1.20};    
03366         // Set parameters for lambda simulation: 
03367         // pt is the average transverse momentum
03368         // aspar the is average transverse mass
03369   
03370         pvMass = pv[i].getMass();       
03371         j = 2;                                              
03372         if ( pv[i].getType() == mesonType ) j = 1;
03373         if ( pv[i].getMass() < 0.4 ) j = 0;
03374         if ( i <= 1 ) j += 3;
03375         if (pv[i].getSide() <= -2) j = 6;
03376         if (j == 6 && (pv[i].getType() == baryonType || pv[i].getType()==antiBaryonType) ) j = 7;
03377         pt    = Amax(0.001, std::sqrt(std::pow(-std::log(1.-G4UniformRand())/bp[j],ptex[j])));
03378         aspar = maspar[j]; 
03379         phi = G4UniformRand()*twopi;
03380         pv[i].setMomentum( pt*std::cos(phi), pt*std::sin(phi) );  // set x- and y-momentum
03381 
03382         for( j=0; j<20; j++ ) binl[j] = j/(19.*pt);   // set the lambda - bins.
03383      
03384         if( pv[i].getSide() > 0 )
03385            et = pvmx[0].getEnergy();
03386         else
03387            et = pvmx[1].getEnergy();
03388      
03389         dndl[0] = 0.0;
03390      
03391         // Start of outer iteration loop
03392 
03393         G4int outerCounter = 0, innerCounter = 0;           // three times.
03394         G4bool eliminateThisParticle = true;
03395         G4bool resetEnergies = true;
03396         while( ++outerCounter < 3 ) 
03397              {
03398                for( l=1; l<20; l++ ) 
03399                   {
03400                     xval  = (binl[l]+binl[l-1])/2.;      // x = lambda /GeV 
03401                     if( xval > 1./pt )
03402                        dndl[l] = dndl[l-1];
03403                     else
03404                        dndl[l] = dndl[l-1] + 
03405                          aspar/std::sqrt( std::pow((1.+aspar*xval*aspar*xval),3) ) *
03406                          (binl[l]-binl[l-1]) * et / 
03407                          std::sqrt( pt*xval*et*pt*xval*et + pt*pt + pvMass*pvMass );
03408                   }  
03409        
03410                // Start of inner iteration loop
03411 
03412                innerCounter = 0;          // try this not more than 7 times. 
03413                while( ++innerCounter < 7 ) 
03414                     {
03415                       l = 1;
03416                       ran = G4UniformRand()*dndl[19];
03417                       while( ( ran >= dndl[l] ) && ( l < 20 ) )l++;
03418                       l = Imin( 19, l );
03419                       xval = Amin( 1.0, pt*(binl[l-1] + G4UniformRand()*(binl[l]-binl[l-1]) ) );
03420                       if( pv[i].getSide() < 0 ) xval *= -1.;
03421                       pv[i].setMomentumAndUpdate( xval*et );   // set the z-momentum
03422                       pvEnergy = pv[i].getEnergy();
03423                       if( pv[i].getSide() > 0 )              // forward side 
03424                         {
03425                           if ( i < 2 )
03426                              { 
03427                                ekin = tavai1 - ekin1;
03428                                if (ekin < 0.) ekin = 0.04*std::fabs(normal());
03429                                G4double pp1 = pv[i].Length();
03430                                if (pp1 >= 1.e-6)
03431                                   { 
03432                                     G4double pp = std::sqrt(ekin*(ekin+2*pvMass));
03433                                     pp = Amax(0.,pp*pp-pt*pt);
03434                                     pp = std::sqrt(pp)*pv[i].getSide()/std::fabs(G4double(pv[i].getSide()));
03435                                     pv[i].setMomentumAndUpdate( pp );
03436                                   }
03437                                else
03438                                   {
03439                                     pv[i].setMomentum(0.,0.,0.);
03440                                     pv[i].setKineticEnergyAndUpdate( ekin);
03441                                   } 
03442                                pvmx[4].Add( pvmx[4], pv[i]);
03443                                outerCounter = 2;
03444                                resetEnergies = false;
03445                                eliminateThisParticle = false;
03446                                break;
03447                              }      
03448                           else if( (ekin1+pvEnergy-pvMass) < 0.95*tavai1 ) 
03449                             {
03450                               pvmx[4].Add( pvmx[4], pv[i] );
03451                               ekin1 += pvEnergy - pvMass;
03452                               pvmx[6].Add( pvmx[4], pvmx[5] );
03453                               pvmx[6].setMomentum( 0.0 );
03454                               outerCounter = 2;            // leave outer loop
03455                               eliminateThisParticle = false;   // don't eliminate this particle
03456                               resetEnergies = false;
03457                               break;                       // next particle
03458                             }
03459                           if( innerCounter > 5 ) break;    // leave inner loop
03460                           
03461                           if( tavai2 >= pvMass ) 
03462                             {                              // switch sides
03463                               pv[i].setSide( -1 );
03464                               tavai1 += pvMass;
03465                               tavai2 -= pvMass;
03466                               iavai2++;
03467                             }
03468                         } 
03469                       else 
03470                         {                                  // backward side
03471                           xval = Amin(0.999,0.95+0.05*targ/20.0);
03472                           if( (ekin2+pvEnergy-pvMass) < xval*tavai2 ) 
03473                             {
03474                               pvmx[5].Add( pvmx[5], pv[i] );
03475                               ekin2 += pvEnergy - pvMass;
03476                               pvmx[6].Add( pvmx[4], pvmx[5] );
03477                               pvmx[6].setMomentum( 0.0 );    // set z-momentum
03478                               outerCounter = 2;              // leave outer iteration
03479                               eliminateThisParticle = false; // don't eliminate this particle
03480                               resetEnergies = false;
03481                               break;                   // leave inner iteration
03482                             }
03483                           if( innerCounter > 5 )break; // leave inner iteration
03484                           
03485                           if( tavai1 >= pvMass ) 
03486                             {                          // switch sides
03487                               pv[i].setSide( 1 );
03488                               tavai1  -= pvMass;
03489                               tavai2  += pvMass;
03490                               iavai2--;
03491                             }
03492                         }
03493                       pv[i].setMomentum( pv[i].getMomentum().x() * 0.9,
03494                                          pv[i].getMomentum().y() * 0.9);
03495                       pt *= 0.9;
03496                       dndl[19] *= 0.9;
03497                     }                                  // closes inner loop
03498 
03499                if (resetEnergies)
03500                     {
03501                       ekin1 = 0.0;
03502                       ekin2 = 0.0;
03503                       pvmx[4].setZero();
03504                       pvmx[5].setZero();
03505                       if (verboseLevel > 1) 
03506                         G4cout << " Reset energies for index " << i << G4endl;
03507                       for( l=i+1; l < vecLen; l++ ) 
03508                          {
03509                            if( (pv[l].getMass() < protonMass) || (pv[l].getSide() > 0) ) 
03510                              {
03511                                 pvEnergy = Amax( pv[l].getMass(),   0.95*pv[l].getEnergy() 
03512                                                                  + 0.05*pv[l].getMass() );
03513                                 pv[l].setEnergyAndUpdate( pvEnergy );
03514                                 if( pv[l].getSide() > 0) 
03515                                   {
03516                                     ekin1 += pv[l].getKineticEnergy();
03517                                     pvmx[4].Add( pvmx[4], pv[l] );
03518                                   } 
03519                                 else 
03520                                   {
03521                                     ekin2 += pv[l].getKineticEnergy();
03522                                     pvmx[5].Add( pvmx[5], pv[l] );
03523                                   }
03524                              }
03525                          }
03526                     }
03527              }                           // closes outer iteration
03528 
03529         if( eliminateThisParticle )      // not enough energy, 
03530           {                              // eliminate this particle
03531             if (verboseLevel > 1)
03532                {
03533                   G4cout << " Eliminate particle with index " << i << G4endl;
03534                   pv[i].Print(i);
03535                }
03536             for( j=i; j < vecLen; j++ ) 
03537                {                                  // shift down
03538                   pv[j] = pv[j+1];
03539                }
03540             vecLen--;
03541             if (vecLen < 2) {
03542               delete [] pvmx;
03543               return;
03544             }
03545             i++;
03546             pvmx[6].Add( pvmx[4], pvmx[5] );
03547             pvmx[6].setMomentum( 0.0 );           // set z-momentum
03548           }
03549       }                                           // closes main for loop
03550    if (verboseLevel > 1)
03551       { G4cout << " pv Vector after lambda fragmentation " << vecLen << G4endl;
03552         pvI.Print(-1);
03553         pvT.Print(-1);
03554         for (i=0; i < vecLen ; i++) pv[i].Print(i);
03555         for (i=0; i < 10; i++) pvmx[i].Print(i);
03556       } 
03557    
03558    // Backward nucleons produced with a cluster model
03559    
03560    pvmx[6].Lor( pvmx[3], pvmx[2] );
03561    pvmx[6].Sub( pvmx[6], pvmx[4] );
03562    pvmx[6].Sub( pvmx[6], pvmx[5] );
03563    if (verboseLevel > 1) pvmx[6].Print(6);
03564 
03565    npg = 0;
03566    G4double rmb0 = 0.;
03567    G4double rmb;
03568    G4double wgt;
03569    G4bool constantCrossSection = true;
03570    for (i = 0; i < vecLen; i++)
03571      {
03572        if(pv[i].getSide() == -3) 
03573           { 
03574             npg++;
03575             rmb0 += pv[i].getMass();
03576           }
03577      }  
03578    if( targ1 == 1 || npg < 2) 
03579      {                     // target particle is the only backward nucleon
03580        ekin = Amin( tavai2-ekin2, centerOfMassEnergy/2.0-protonMass );
03581        if( ekin < 0.04 ) ekin = 0.04 * std::fabs( normal() );
03582        G4double pp = std::sqrt(ekin*(ekin+2*pv[1].getMass()));
03583        G4double pp1 = pvmx[6].Length();
03584        if(pp1 < 1.e-6)
03585          {
03586             pv[1].setKineticEnergyAndUpdate(ekin);
03587          }
03588        else
03589          {
03590             pv[1].setMomentum(pvmx[6].getMomentum());
03591             pv[1].SmulAndUpdate(pv[1],pp/pp1);
03592          }
03593        pvmx[5].Add( pvmx[5], pv[1] );
03594      } 
03595    else 
03596      {
03597        G4double cpar[] = { 0.6, 0.6, 0.35, 0.15, 0.10 };
03598        G4double gpar[] = { 2.6, 2.6, 1.80, 1.30, 1.20 };
03599 
03600        G4int tempCount = Imin( 5, targ1 ) - 1;
03601 
03602        rmb = rmb0 + std::pow(-std::log(1.0-G4UniformRand()), cpar[tempCount])/gpar[tempCount];
03603        pvEnergy = pvmx[6].getEnergy();
03604        if ( rmb > pvEnergy ) rmb = pvEnergy; 
03605        pvmx[6].setMass( rmb );
03606        pvmx[6].setEnergyAndUpdate( pvEnergy );
03607        pvmx[6].Smul( pvmx[6], -1. );
03608        if (verboseLevel > 1) {
03609          G4cout << " General Vectors before input to NBodyPhaseSpace "
03610                 << targ1 << " " << tempCount << " " << rmb0 << " " 
03611                 << rmb << " " << pvEnergy << G4endl;
03612          for (i=0; i<10; i++) pvmx[i].Print(i);
03613        }
03614 
03615        //  tempV contains the backward nucleons
03616 
03617        G4HEVector* tempV = new G4HEVector[18];
03618        npg = 0;
03619        for( i=0; i < vecLen; i++ )  
03620          {
03621            if( pv[i].getSide() == -3 ) tempV[npg++] = pv[i]; 
03622          }
03623 
03624        wgt = NBodyPhaseSpace( pvmx[6].getMass(), constantCrossSection, tempV, npg );
03625 
03626        npg = 0;
03627        for( i=0; i < vecLen; i++ ) 
03628          {
03629            if( pv[i].getSide() == -3 ) 
03630              {
03631                pv[i].setMomentum( tempV[npg++].getMomentum());
03632                pv[i].SmulAndUpdate( pv[i], 1.);
03633                pv[i].Lor( pv[i], pvmx[6] );
03634                pvmx[5].Add( pvmx[5], pv[i] );
03635              }
03636          }
03637        delete [] tempV; 
03638      }
03639    if( vecLen <= 2 ) 
03640      {
03641        successful = false;
03642        return;
03643      }
03644 
03645    // Lorentz transformation in lab system
03646 
03647    targ = 0;
03648    for( i=0; i < vecLen; i++ ) 
03649       {
03650         if( pv[i].getType() == baryonType )targ++;
03651         if( pv[i].getType() == antiBaryonType )targ++;
03652         pv[i].Lor( pv[i], pvmx[1] );
03653       }
03654    targ = Imax( 1, targ );
03655 
03656    G4bool dum(0);
03657    if( lead ) 
03658      {
03659        for( i=0; i<vecLen; i++ ) 
03660           {
03661             if( pv[i].getCode() == lead ) 
03662               {
03663                 dum = false;
03664                 break;
03665               }
03666           }
03667        if( dum ) 
03668          {
03669            i = 0;          
03670  
03671            if(   (    (leadParticle.getType() == baryonType ||
03672                        leadParticle.getType() == antiBaryonType)
03673                    && (pv[1].getType() == baryonType ||
03674                        pv[1].getType() == antiBaryonType))
03675               || (    (leadParticle.getType() == mesonType)
03676                    && (pv[1].getType() == mesonType)))
03677              {
03678                i = 1;
03679              } 
03680             ekin = pv[i].getKineticEnergy();
03681             pv[i] = leadParticle;
03682             if( pv[i].getFlag() )
03683                 pv[i].setTOF( -1.0 );
03684             else
03685                 pv[i].setTOF( 1.0 );
03686             pv[i].setKineticEnergyAndUpdate( ekin );
03687          }
03688      }
03689 
03690    pvmx[3].setMass( incidentMass);
03691    pvmx[3].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
03692    
03693    G4double ekin0 = pvmx[3].getKineticEnergy();
03694    
03695    pvmx[4].setMass ( protonMass * targ);
03696    pvmx[4].setEnergy( protonMass * targ);
03697    pvmx[4].setMomentum(0.,0.,0.);
03698    pvmx[4].setKineticEnergy(0.);
03699 
03700    ekin = pvmx[3].getEnergy() + pvmx[4].getEnergy();
03701 
03702    pvmx[5].Add( pvmx[3], pvmx[4] );
03703    pvmx[3].Lor( pvmx[3], pvmx[5] );
03704    pvmx[4].Lor( pvmx[4], pvmx[5] );
03705    
03706    G4double tecm = pvmx[3].getEnergy() + pvmx[4].getEnergy();
03707 
03708    pvmx[7].setZero();
03709    
03710    ekin1 = 0.0;   
03711    G4double teta; 
03712    
03713    for( i=0; i < vecLen; i++ ) 
03714       {
03715         pvmx[7].Add( pvmx[7], pv[i] );
03716         ekin1 += pv[i].getKineticEnergy();
03717         ekin  -= pv[i].getMass();
03718       }
03719    
03720    if( vecLen > 1 && vecLen < 19 ) 
03721      {
03722        constantCrossSection = true;
03723        G4HEVector pw[18];
03724        for(i=0;i<vecLen;i++) pw[i] = pv[i];
03725        wgt = NBodyPhaseSpace( tecm, constantCrossSection, pw, vecLen );
03726        ekin = 0.0;
03727        for( i=0; i < vecLen; i++ ) 
03728           {
03729             pvmx[6].setMass( pw[i].getMass());
03730             pvmx[6].setMomentum( pw[i].getMomentum() );
03731             pvmx[6].SmulAndUpdate( pvmx[6], 1.);
03732             pvmx[6].Lor( pvmx[6], pvmx[4] );
03733             ekin += pvmx[6].getKineticEnergy();
03734           }
03735        teta = pvmx[7].Ang( pvmx[3] );
03736        if (verboseLevel > 1) 
03737          G4cout << " vecLen > 1 && vecLen < 19 " << teta << " " << ekin0
03738                 << " " << ekin1 << " " << ekin << G4endl;
03739      }
03740 
03741    if( ekin1 != 0.0 ) 
03742      {
03743        pvmx[6].setZero();
03744        wgt = ekin/ekin1;
03745        ekin1 = 0.;
03746        for( i=0; i < vecLen; i++ ) 
03747           {
03748             pvMass = pv[i].getMass();
03749             ekin   = pv[i].getKineticEnergy() * wgt;
03750             pv[i].setKineticEnergyAndUpdate( ekin );
03751             ekin1 += ekin;
03752             pvmx[6].Add( pvmx[6], pv[i] );
03753           }
03754        teta = pvmx[6].Ang( pvmx[3] );
03755        if (verboseLevel > 1) 
03756          G4cout << " ekin1 != 0 " << teta << " " << ekin0 << " " 
03757                 << ekin1 << G4endl;
03758      }
03759 
03760    // Do some smearing in the transverse direction due to Fermi motion.
03761 
03762    G4double ry   = G4UniformRand();
03763    G4double rz   = G4UniformRand();
03764    G4double rx   = twopi*rz;
03765    G4double a1   = std::sqrt(-2.0*std::log(ry));
03766    G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
03767    G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
03768 
03769    for (i = 0; i < vecLen; i++)
03770      pv[i].setMomentum( pv[i].getMomentum().x()+rantarg1,
03771                         pv[i].getMomentum().y()+rantarg2 );
03772                                          
03773    if (verboseLevel > 1) {
03774      pvmx[6].setZero();
03775      for (i = 0; i < vecLen; i++) pvmx[6].Add( pvmx[6], pv[i] );  
03776      teta = pvmx[6].Ang( pvmx[3] );   
03777      G4cout << " After smearing " << teta << G4endl;
03778    }
03779 
03780   // Rotate in the direction of the primary particle momentum (z-axis).
03781   // This does disturb our inclusive distributions somewhat, but it is 
03782   // necessary for momentum conservation.
03783 
03784   // Also subtract binding energies and make some further corrections 
03785   // if required.
03786 
03787   G4double dekin = 0.0;
03788   G4int npions = 0;    
03789   G4double ek1 = 0.0;
03790   G4double alekw, xxh;
03791   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
03792   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
03793   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70}; 
03794 
03795   for (i = 0; i < vecLen; i++) { 
03796     pv[i].Defs1( pv[i], pvI );
03797     if (atomicWeight > 1.5) {
03798       ekin = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
03799       alekw = std::log( incidentKineticEnergy );
03800       xxh = 1.;
03801       if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
03802         if (pv[i].getCode() == pionZeroCode) {
03803           if (G4UniformRand() < std::log(atomicWeight)) {            
03804             if (alekw > alem[0]) {
03805               G4int jmax = 1;
03806               for (j = 1; j < 8; j++) {
03807                 if (alekw < alem[j]) {
03808                   jmax = j;
03809                   break;
03810                 }
03811               }
03812               xxh = (val0[jmax] - val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
03813                    + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
03814               xxh = 1. - xxh;
03815             }
03816           }
03817         }
03818       }  
03819       dekin += ekin*(1.-xxh);
03820       ekin *= xxh;
03821       pv[i].setKineticEnergyAndUpdate( ekin );
03822       pvCode = pv[i].getCode();
03823       if ((pvCode == pionPlusCode) ||
03824           (pvCode == pionMinusCode) ||
03825           (pvCode == pionZeroCode)) {
03826         npions += 1;
03827         ek1 += ekin; 
03828       }
03829     }
03830   }
03831 
03832    if( (ek1 > 0.0) && (npions > 0) ) 
03833       {
03834         dekin = 1.+dekin/ek1;
03835         for (i = 0; i < vecLen; i++)
03836           {
03837             pvCode = pv[i].getCode();
03838             if((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode)) 
03839               {
03840                 ekin = Amax( 1.0e-6, pv[i].getKineticEnergy() * dekin );
03841                 pv[i].setKineticEnergyAndUpdate( ekin );
03842               }
03843           }
03844       }
03845    if (verboseLevel > 1)
03846       { G4cout << " Lab-System " << ek1 << " " << npions << G4endl;
03847         for (i=0; i<vecLen; i++) pv[i].Print(i);
03848       }
03849 
03850    // Add black track particles
03851    // The total number of particles produced is restricted to 198
03852    // this may have influence on very high energies
03853 
03854    if (verboseLevel > 1) G4cout << " Evaporation " << atomicWeight << " " <<
03855                      excitationEnergyGNP << " " << excitationEnergyDTA << G4endl;
03856 
03857    if( atomicWeight > 1.5 ) 
03858      {
03859 
03860        G4double sprob, cost, sint, pp, eka;
03861        G4int spall(0), nbl(0);
03862        //  sprob is the probability of self-absorption in heavy molecules
03863 
03864        if( incidentKineticEnergy < 5.0 )
03865          sprob = 0.0;
03866        else
03867          //      sprob = Amin( 1.0, 0.6*std::log(incidentKineticEnergy-4.0) );
03868          sprob = Amin(1., 0.000314*atomicWeight*std::log(incidentKineticEnergy-4.)); 
03869 
03870        // First add protons and neutrons
03871 
03872        if( excitationEnergyGNP >= 0.001 ) 
03873          {
03874            //  nbl = number of proton/neutron black track particles
03875            //  tex is their total kinetic energy (GeV)
03876        
03877            nbl = Poisson( (1.5+1.25*targ)*excitationEnergyGNP/
03878                                          (excitationEnergyGNP+excitationEnergyDTA));
03879            if( targ+nbl > atomicWeight ) nbl = (int)(atomicWeight - targ);
03880            if (verboseLevel > 1) 
03881              G4cout << " evaporation " << targ << " " << nbl << " " 
03882                     << sprob << G4endl; 
03883            spall = targ;
03884            if( nbl > 0) 
03885              {
03886                ekin = excitationEnergyGNP/nbl;
03887                ekin2 = 0.0;
03888                for( i=0; i<nbl; i++ ) 
03889                   {
03890                     if( G4UniformRand() < sprob ) continue;
03891                     if( ekin2 > excitationEnergyGNP) break;
03892                     ran = G4UniformRand();
03893                     ekin1 = -ekin*std::log(ran) - cfa*(1.0+0.5*normal());
03894                     if (ekin1 < 0) ekin1 = -0.010*std::log(ran);
03895                     ekin2 += ekin1;
03896                     if( ekin2 > excitationEnergyGNP)
03897                     ekin1 = Amax( 1.0e-6, excitationEnergyGNP-(ekin2-ekin1) );
03898                     if( G4UniformRand() > (1.0-atomicNumber/(atomicWeight)))
03899                        pv[vecLen].setDefinition( "Proton");
03900                     else
03901                        pv[vecLen].setDefinition( "Neutron");
03902                     spall++;
03903                     cost = G4UniformRand() * 2.0 - 1.0;
03904                     sint = std::sqrt(std::fabs(1.0-cost*cost));
03905                     phi = twopi * G4UniformRand();
03906                     pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
03907                     pv[vecLen].setSide( -4 );
03908                     pvMass = pv[vecLen].getMass();
03909                     pv[vecLen].setTOF( 1.0 );
03910                     pvEnergy = ekin1 + pvMass;
03911                     pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
03912                     pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
03913                                                      pp*sint*std::cos(phi),
03914                                                      pp*cost );
03915                     if (verboseLevel > 1) pv[vecLen].Print(vecLen);
03916                     vecLen++;
03917                   }
03918                if( (atomicWeight >= 10.0 ) && (incidentKineticEnergy <= 2.0) ) 
03919                   {
03920                     G4int ika, kk = 0;
03921                     eka = incidentKineticEnergy;
03922                     if( eka > 1.0 )eka *= eka;
03923                     eka = Amax( 0.1, eka );
03924                     ika = G4int(3.6*std::exp((atomicNumber*atomicNumber
03925                                 /atomicWeight-35.56)/6.45)/eka);
03926                     if( ika > 0 ) 
03927                       {
03928                         for( i=(vecLen-1); i>=0; i-- ) 
03929                            {
03930                              if( (pv[i].getCode() == protonCode) && pv[i].getFlag() ) 
03931                                {
03932                                  pTemp = pv[i];
03933                                  pv[i].setDefinition( "Neutron");
03934                                  pv[i].setMomentumAndUpdate(pTemp.getMomentum());
03935                                  if (verboseLevel > 1) pv[i].Print(i);
03936                                  if( ++kk > ika ) break;
03937                                }
03938                            }
03939                       }
03940                   }
03941              }
03942          }
03943 
03944      // Finished adding proton/neutron black track particles
03945      // now, try to add deuterons, tritons and alphas
03946      
03947      if( excitationEnergyDTA >= 0.001 ) 
03948        {
03949          nbl = Poisson( (1.5+1.25*targ)*excitationEnergyDTA
03950                                       /(excitationEnergyGNP+excitationEnergyDTA));
03951   
03952          //    nbl is the number of deutrons, tritons, and alphas produced
03953        
03954          if( nbl > 0 ) 
03955            {
03956              ekin = excitationEnergyDTA/nbl;
03957              ekin2 = 0.0;
03958              for( i=0; i<nbl; i++ ) 
03959                 {
03960                   if( G4UniformRand() < sprob ) continue;
03961                   if( ekin2 > excitationEnergyDTA) break;
03962                   ran = G4UniformRand();
03963                   ekin1 = -ekin*std::log(ran)-cfa*(1.+0.5*normal());
03964                   if( ekin1 < 0.0 ) ekin1 = -0.010*std::log(ran);
03965                   ekin2 += ekin1;
03966                   if( ekin2 > excitationEnergyDTA)
03967                      ekin1 = Amax( 1.0e-6, excitationEnergyDTA-(ekin2-ekin1));
03968                   cost = G4UniformRand()*2.0 - 1.0;
03969                   sint = std::sqrt(std::fabs(1.0-cost*cost));
03970                   phi = twopi*G4UniformRand();
03971                   ran = G4UniformRand();
03972                   if( ran <= 0.60 ) 
03973                       pv[vecLen].setDefinition( "Deuteron");
03974                   else if (ran <= 0.90)
03975                       pv[vecLen].setDefinition( "Triton");
03976                   else
03977                       pv[vecLen].setDefinition( "Alpha");
03978                   spall += (int)(pv[vecLen].getMass() * 1.066);
03979                   if( spall > atomicWeight ) break;
03980                   pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
03981                   pv[vecLen].setSide( -4 );
03982                   pvMass = pv[vecLen].getMass();
03983                   pv[vecLen].setSide( pv[vecLen].getCode());
03984                   pv[vecLen].setTOF( 1.0 );
03985                   pvEnergy = pvMass + ekin1;
03986                   pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
03987                   pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
03988                                                    pp*sint*std::cos(phi),
03989                                                    pp*cost );
03990                   if (verboseLevel > 1) pv[vecLen].Print(vecLen);
03991                   vecLen++;
03992                 }
03993             }
03994         }
03995     }
03996    if( centerOfMassEnergy <= (4.0+G4UniformRand()) ) 
03997      {
03998        for( i=0; i<vecLen; i++ ) 
03999          {
04000            G4double etb = pv[i].getKineticEnergy();
04001            if( etb >= incidentKineticEnergy ) 
04002               pv[i].setKineticEnergyAndUpdate( incidentKineticEnergy );
04003          }
04004      }
04005 
04006    // Calculate time delay for nuclear reactions
04007 
04008    G4double tof = incidentTOF;
04009    if(     (atomicWeight >= 1.5) && (atomicWeight <= 230.0) 
04010         && (incidentKineticEnergy <= 0.2) )
04011            tof -= 500.0 * std::exp(-incidentKineticEnergy /0.04) * std::log( G4UniformRand() );
04012    for ( i=0; i < vecLen; i++)     
04013      { 
04014        
04015        pv[i].setTOF ( tof );
04016 //       vec[i].SetTOF ( tof );
04017      }
04018 
04019    for(i=0; i<vecLen; i++)
04020    {
04021      if(pv[i].getName() == "KaonZero" || pv[i].getName() == "AntiKaonZero")
04022      {
04023        pvmx[0] = pv[i];
04024        if(G4UniformRand() < 0.5) pv[i].setDefinition("KaonZeroShort");
04025        else                    pv[i].setDefinition("KaonZeroLong");
04026        pv[i].setMomentumAndUpdate(pvmx[0].getMomentum());
04027      }
04028    } 
04029 
04030    successful = true;
04031    delete [] pvmx;
04032    return;
04033  }

void G4HEInelastic::MediumEnergyClusterProduction ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
G4double excitationEnergyGNP,
G4double excitationEnergyDTA,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 4036 of file G4HEInelastic.cc.

References G4HEVector::Add(), Amax(), Amin(), G4HEVector::Ang(), AntiProton, DBL_MAX, G4cout, G4endl, G4UniformRand, G4HEVector::getCode(), G4HEVector::getEnergy(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getTotalMomentum(), G4HEVector::getType(), Imin(), KaonPlus, G4HEVector::Length(), G4HEVector::Lor(), NBodyPhaseSpace(), Neutron, neutronCode, normal(), PionMinus, PionPlus, PionZero, Poisson(), G4InuclParticleNames::pp, G4HEVector::Print(), Proton, G4HEVector::setDefinition(), G4HEVector::setEnergy(), G4HEVector::setFlag(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMass(), G4HEVector::setMomentum(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setSide(), G4HEVector::setTOF(), G4HEVector::setZero(), G4HEVector::Smul(), G4HEVector::SmulAndUpdate(), sqr(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

04045 {
04046 // For low multiplicity in the first intranuclear interaction the cascading 
04047 // process as described in G4HEInelastic::MediumEnergyCascading does not work 
04048 // satisfactorily. From experimental data it is strongly suggested to use 
04049 // a two- body resonance model.   
04050 //  
04051 //  All quantities on the G4HEVector Array pv are in GeV- units.
04052 
04053   G4int protonCode       = Proton.getCode();
04054   G4double protonMass    = Proton.getMass();
04055   G4int neutronCode      = Neutron.getCode();
04056   G4double kaonPlusMass  = KaonPlus.getMass();
04057   G4int pionPlusCode     = PionPlus.getCode();    
04058   G4int pionZeroCode     = PionZero.getCode();    
04059   G4int pionMinusCode = PionMinus.getCode(); 
04060   G4String mesonType = PionPlus.getType();
04061   G4String baryonType = Proton.getType(); 
04062   G4String antiBaryonType = AntiProton.getType(); 
04063    
04064   G4double targetMass = targetParticle.getMass();
04065 
04066   G4int incidentCode = incidentParticle.getCode();
04067   G4double incidentMass = incidentParticle.getMass();
04068   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
04069   G4double incidentEnergy = incidentParticle.getEnergy();
04070   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
04071   G4String incidentType = incidentParticle.getType();
04072 //   G4double incidentTOF           = incidentParticle.getTOF();   
04073   G4double incidentTOF = 0.;
04074    
04075   // some local variables
04076 
04077   G4int i, j;
04078    
04079   if (verboseLevel > 1)
04080     G4cout << " G4HEInelastic::MediumEnergyClusterProduction " << G4endl;
04081 
04082   if (incidentTotalMomentum < 0.01) {
04083     successful = false;
04084     return;
04085   }
04086   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
04087                                         +2.*targetMass*incidentEnergy);
04088 
04089   G4HEVector pvI = incidentParticle;  // for the incident particle
04090   pvI.setSide( 1 );
04091 
04092   G4HEVector pvT = targetParticle;   // for the target particle
04093   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
04094   pvT.setSide( -1 );
04095   pvT.setTOF( -1.);
04096  
04097   // Distribute particles in forward and backward hemispheres. Note that 
04098   // only low multiplicity events from FirstIntInNuc.... should go into 
04099   // this routine.
04100  
04101   G4int targ = 0;  
04102   G4int ifor = 0; 
04103   G4int iback = 0;
04104   G4int pvCode;
04105   G4double pvMass, pvEnergy; 
04106 
04107    pv[0].setSide(  1 );
04108    pv[1].setSide( -1 );
04109    for(i = 0; i < vecLen; i++)
04110       {
04111         if (i > 1)
04112            {
04113               if( G4UniformRand() < 0.5) 
04114                 {
04115                   pv[i].setSide( 1 );
04116                   if (++ifor > 18) 
04117                      { 
04118                        pv[i].setSide( -1 );
04119                        ifor--;
04120                        iback++;
04121                      }
04122                 }
04123               else
04124                 {
04125                   pv[i].setSide( -1 );
04126                   if (++iback > 18)
04127                      { 
04128                        pv[i].setSide( 1 );
04129                        ifor++;
04130                        iback--;
04131                      }
04132                 }
04133            }
04134 
04135         pvCode = pv[i].getCode();
04136 
04137         if (   (    (incidentCode == protonCode) || (incidentCode == neutronCode)
04138                  || (incidentType == mesonType) )
04139             && (    (pvCode == pionPlusCode) || (pvCode == pionMinusCode) )
04140             && (    (G4UniformRand() < (10.-incidentTotalMomentum)/6.) )
04141             && (    (G4UniformRand() < atomicWeight/300.) ) )
04142            { 
04143                if (G4UniformRand() > atomicNumber/atomicWeight) 
04144                   pv[i].setDefinition( "Neutron");
04145                else
04146                   pv[i].setDefinition( "Proton");
04147                targ++;
04148            }    
04149         pv[i].setTOF( incidentTOF );                 
04150       }    
04151    G4double tb = 2. * iback;
04152    if (centerOfMassEnergy < (2+G4UniformRand())) tb = (2.*iback + vecLen)/2.;
04153    
04154    G4double nucsup[] = { 1.0, 0.8, 0.6, 0.5, 0.4}; 
04155 
04156    G4double xtarg = Amax(0.01, (0.312+0.2*std::log(std::log(centerOfMassEnergy*centerOfMassEnergy)))
04157                              * (std::pow(atomicWeight,0.33)-1.) * tb);
04158    G4int ntarg = Poisson(xtarg);
04159    if (ntarg > 0)
04160       {
04161         G4int ipx = Imin(4, (G4int)(incidentTotalMomentum/3.));
04162         for (i=0; i < ntarg; i++)
04163             { 
04164                if (G4UniformRand() < nucsup[ipx] )
04165                   {
04166                      if (G4UniformRand() < (1.- atomicNumber/atomicWeight))
04167                         pv[vecLen].setDefinition( "Neutron");
04168                      else
04169                         pv[vecLen].setDefinition( "Proton");
04170                      targ++;
04171                   }   
04172                else
04173                   {
04174                      G4double ran = G4UniformRand();
04175                      if (ran < 0.3333 ) 
04176                         pv[vecLen].setDefinition( "PionPlus");
04177                      else if (ran < 0.6666)
04178                         pv[vecLen].setDefinition( "PionZero");
04179                      else
04180                         pv[vecLen].setDefinition( "PionMinus");
04181                   }
04182                pv[vecLen].setSide( -2 );        
04183                pv[vecLen].setFlag( true );
04184                pv[vecLen].setTOF( incidentTOF );
04185                vecLen++;
04186             }
04187       }
04188 
04189    // Mark leading particles for incident strange particles and antibaryons, 
04190    // for all other we assume that the first and second particle are the 
04191    // leading particles. 
04192    // We need this later for kinematic aspects of strangeness conservation.
04193                           
04194    G4int lead = 0;                   
04195    G4HEVector leadParticle;
04196    if( (incidentMass >= kaonPlusMass-0.05) && (incidentCode != protonCode)  
04197                                            && (incidentCode != neutronCode) ) 
04198          {       
04199            G4double pMass = pv[0].getMass();
04200            G4int    pCode = pv[0].getCode();
04201            if( (pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
04202                                             && (pCode != neutronCode) ) 
04203                   {       
04204                     lead = pCode; 
04205                     leadParticle = pv[0];                           
04206                   } 
04207            else   
04208                   {
04209                     pMass = pv[1].getMass();
04210                     pCode = pv[1].getCode();
04211                     if( (pMass >= kaonPlusMass-0.05) && (pCode != protonCode) 
04212                                                      && (pCode != neutronCode) ) 
04213                         {       
04214                           lead = pCode;
04215                           leadParticle = pv[1];
04216                         }
04217                   }
04218          }
04219 
04220    if (verboseLevel > 1) {
04221      G4cout << " pv Vector after initialization " << vecLen << G4endl;
04222      pvI.Print(-1);
04223      pvT.Print(-1);
04224      for (i=0; i < vecLen ; i++) pv[i].Print(i);
04225    }     
04226 
04227    G4double tavai = 0.;
04228    for(i=0;i<vecLen;i++) if(pv[i].getSide() != -2) tavai  += pv[i].getMass();
04229 
04230    while (tavai > centerOfMassEnergy)
04231       {
04232          for (i=vecLen-1; i >= 0; i--)
04233             {
04234               if (pv[i].getSide() != -2)
04235                  {
04236                     tavai -= pv[i].getMass();
04237                     if( i != vecLen-1) 
04238                       {
04239                         for (j=i; j < vecLen; j++)
04240                            {
04241                               pv[j]  = pv[j+1];
04242                            }
04243                       }
04244                     if ( --vecLen < 2)
04245                       {
04246                         successful = false;
04247                         return;
04248                       }
04249                     break;
04250                  }
04251             }    
04252       }
04253 
04254    // Now produce 3 Clusters:
04255    // 1. forward cluster
04256    // 2. backward meson cluster
04257    // 3. backward nucleon cluster
04258 
04259    G4double rmc0 = 0., rmd0 = 0., rme0 = 0.;
04260    G4int    ntc  = 0,  ntd  = 0,  nte  = 0;
04261    
04262    for (i=0; i < vecLen; i++)
04263       {
04264         if(pv[i].getSide() > 0)
04265            {
04266              if(ntc < 17)
04267                { 
04268                  rmc0 += pv[i].getMass();
04269                  ntc++;
04270                }
04271              else
04272                {
04273                  if(ntd < 17)
04274                    {
04275                      pv[i].setSide(-1);
04276                      rmd0 += pv[i].getMass();
04277                      ntd++;
04278                    }
04279                  else
04280                    {
04281                      pv[i].setSide(-2);
04282                      rme0 += pv[i].getMass();
04283                      nte++;
04284                    }
04285                }
04286            }  
04287         else if (pv[i].getSide() == -1)
04288            {
04289              if(ntd < 17)
04290                 {
04291                    rmd0 += pv[i].getMass();
04292                    ntd++;
04293                 }
04294              else
04295                 {
04296                    pv[i].setSide(-2); 
04297                    rme0 += pv[i].getMass();
04298                    nte++;
04299                 }           
04300            }
04301         else
04302            {
04303              rme0 += pv[i].getMass();
04304              nte++;
04305            } 
04306       }         
04307 
04308    G4double cpar[] = {0.6, 0.6, 0.35, 0.15, 0.10};
04309    G4double gpar[] = {2.6, 2.6, 1.80, 1.30, 1.20};
04310     
04311    G4double rmc = rmc0, rmd = rmd0, rme = rme0; 
04312    G4int ntc1 = Imin(4,ntc-1);
04313    G4int ntd1 = Imin(4,ntd-1);
04314    G4int nte1 = Imin(4,nte-1);
04315    if (ntc > 1) rmc = rmc0 + std::pow(-std::log(1.-G4UniformRand()),cpar[ntc1])/gpar[ntc1];
04316    if (ntd > 1) rmd = rmd0 + std::pow(-std::log(1.-G4UniformRand()),cpar[ntd1])/gpar[ntd1];
04317    if (nte > 1) rme = rme0 + std::pow(-std::log(1.-G4UniformRand()),cpar[nte1])/gpar[nte1];
04318    while( (rmc+rmd) > centerOfMassEnergy)
04319       {
04320         if ((rmc == rmc0) && (rmd == rmd0))
04321           { 
04322             rmd *= 0.999*centerOfMassEnergy/(rmc+rmd);
04323             rmc *= 0.999*centerOfMassEnergy/(rmc+rmd);
04324           }
04325         else
04326           {
04327             rmc = 0.1*rmc0 + 0.9*rmc;
04328             rmd = 0.1*rmd0 + 0.9*rmd;
04329           }   
04330       }             
04331    if(verboseLevel > 1) 
04332      G4cout << " Cluster Masses: " << ntc << " " << rmc << " " << ntd << " "
04333             << rmd << " " << nte << " " << rme << G4endl;
04334  
04335    
04336    G4HEVector* pvmx = new G4HEVector[11];
04337 
04338    pvmx[1].setMass( incidentMass);
04339    pvmx[1].setMomentumAndUpdate( 0., 0., incidentTotalMomentum);
04340    pvmx[2].setMass( targetMass);
04341    pvmx[2].setMomentumAndUpdate( 0., 0., 0.);
04342    pvmx[0].Add( pvmx[1], pvmx[2] );
04343    pvmx[1].Lor( pvmx[1], pvmx[0] );
04344    pvmx[2].Lor( pvmx[2], pvmx[0] );
04345 
04346    G4double pf = std::sqrt(Amax(0.0001,  sqr(sqr(centerOfMassEnergy) + rmd*rmd -rmc*rmc)
04347                                  - 4*sqr(centerOfMassEnergy)*rmd*rmd))/(2.*centerOfMassEnergy);
04348    pvmx[3].setMass( rmc );
04349    pvmx[4].setMass( rmd );
04350    pvmx[3].setEnergy( std::sqrt(pf*pf + rmc*rmc) );
04351    pvmx[4].setEnergy( std::sqrt(pf*pf + rmd*rmd) );
04352    
04353    G4double tvalue = -DBL_MAX;
04354    G4double bvalue = Amax(0.01, 4.0 + 1.6*std::log(incidentTotalMomentum));
04355    if (bvalue != 0.0) tvalue = std::log(G4UniformRand())/bvalue;
04356    G4double pin = pvmx[1].Length();
04357    G4double tacmin = sqr( pvmx[1].getEnergy() - pvmx[3].getEnergy()) - sqr( pin - pf);
04358    G4double ctet   = Amax(-1., Amin(1., 1.+2.*(tvalue-tacmin)/Amax(1.e-10, 4.*pin*pf)));
04359    G4double stet   = std::sqrt(Amax(0., 1.0 - ctet*ctet));
04360    G4double phi    = twopi * G4UniformRand();
04361    pvmx[3].setMomentum( pf * stet * std::sin(phi), 
04362                       pf * stet * std::cos(phi),
04363                       pf * ctet           );
04364    pvmx[4].Smul( pvmx[3], -1.);
04365    
04366    if (nte > 0)
04367       {
04368         G4double ekit1 = 0.04;
04369         G4double ekit2 = 0.6;
04370         G4double gaval = 1.2;
04371         if (incidentKineticEnergy <= 5.)
04372            {
04373              ekit1 *= sqr(incidentKineticEnergy)/25.;
04374              ekit2 *= sqr(incidentKineticEnergy)/25.;
04375            }
04376         G4double avalue = (1.-gaval)/(std::pow(ekit2, 1.-gaval)-std::pow(ekit1, 1.-gaval));
04377         for (i=0; i < vecLen; i++)
04378             {
04379               if (pv[i].getSide() == -2)
04380                  {
04381                    G4double ekit = std::pow(G4UniformRand()*(1.-gaval)/avalue +std::pow(ekit1, 1.-gaval),
04382                                        1./(1.-gaval));
04383                    pv[i].setKineticEnergyAndUpdate( ekit );
04384                    ctet = Amax(-1., Amin(1., std::log(2.23*G4UniformRand()+0.383)/0.96));
04385                    stet = std::sqrt( Amax( 0.0, 1. - ctet*ctet ));
04386                    phi  = G4UniformRand()*twopi;
04387                    G4double pp = pv[i].Length();
04388                    pv[i].setMomentum( pp * stet * std::sin(phi),
04389                                       pp * stet * std::cos(phi),
04390                                       pp * ctet           );
04391                    pv[i].Lor( pv[i], pvmx[0] );
04392                  }              
04393             }             
04394       }
04395 //   pvmx[1] = pvmx[3];
04396 //   pvmx[2] = pvmx[4];
04397    pvmx[5].SmulAndUpdate( pvmx[3], -1.);
04398    pvmx[6].SmulAndUpdate( pvmx[4], -1.);
04399 
04400    if (verboseLevel > 1) {
04401      G4cout << " General vectors before Phase space Generation " << G4endl;
04402      for (i=0; i<7; i++) pvmx[i].Print(i);
04403    }  
04404 
04405 
04406    G4HEVector* tempV = new G4HEVector[18];
04407    G4bool constantCrossSection = true;
04408    G4double wgt;
04409    G4int npg;
04410 
04411    if (ntc > 1)
04412       {
04413         npg = 0;
04414         for (i=0; i < vecLen; i++)
04415             {
04416               if (pv[i].getSide() > 0)
04417                  {
04418                     tempV[npg++] = pv[i];
04419                     if(verboseLevel > 1) pv[i].Print(i);
04420                  }
04421             }
04422         wgt = NBodyPhaseSpace( pvmx[3].getMass(), constantCrossSection, tempV, npg);
04423                      
04424         npg = 0;
04425         for (i=0; i < vecLen; i++)
04426             {
04427               if (pv[i].getSide() > 0)
04428                  {
04429                    pv[i].setMomentum( tempV[npg++].getMomentum());
04430                    pv[i].SmulAndUpdate( pv[i], 1. );
04431                    pv[i].Lor( pv[i], pvmx[5] );
04432                    if(verboseLevel > 1) pv[i].Print(i);
04433                  }
04434             }
04435       }
04436    else if(ntc == 1)
04437       {
04438         for(i=0; i<vecLen; i++)
04439           {
04440             if(pv[i].getSide() > 0) pv[i].setMomentumAndUpdate(pvmx[3].getMomentum());
04441             if(verboseLevel > 1) pv[i].Print(i); 
04442           }
04443       }
04444    else
04445       {
04446       }
04447      
04448    if (ntd > 1)
04449       {
04450         npg = 0;
04451         for (i=0; i < vecLen; i++)
04452             {
04453               if (pv[i].getSide() == -1)
04454                  {
04455                     tempV[npg++] = pv[i];
04456                     if(verboseLevel > 1) pv[i].Print(i);
04457                  }
04458             }
04459         wgt = NBodyPhaseSpace( pvmx[4].getMass(), constantCrossSection, tempV, npg);
04460                      
04461         npg = 0;
04462         for (i=0; i < vecLen; i++)
04463             {
04464               if (pv[i].getSide() == -1)
04465                  {
04466                    pv[i].setMomentum( tempV[npg++].getMomentum());
04467                    pv[i].SmulAndUpdate( pv[i], 1.);
04468                    pv[i].Lor( pv[i], pvmx[6] );
04469                    if(verboseLevel > 1) pv[i].Print(i);
04470                  }
04471             }
04472       }
04473    else if(ntd == 1)
04474       {
04475         for(i=0; i<vecLen; i++)
04476           {
04477             if(pv[i].getSide() == -1) pv[i].setMomentumAndUpdate(pvmx[4].getMomentum());
04478             if(verboseLevel > 1) pv[i].Print(i);
04479           }
04480       }
04481    else
04482       {
04483       }
04484 
04485    if(verboseLevel > 1)
04486      {
04487        G4cout << " Vectors after PhaseSpace generation " << G4endl;
04488        for(i=0;i<vecLen; i++) pv[i].Print(i);
04489      } 
04490 
04491    // Lorentz transformation in lab system
04492 
04493    targ = 0;
04494    for( i=0; i < vecLen; i++ ) 
04495       {
04496         if( pv[i].getType() == baryonType )targ++;
04497         if( pv[i].getType() == antiBaryonType )targ++;
04498         pv[i].Lor( pv[i], pvmx[2] );
04499       }
04500    if (targ <1) targ =1;
04501 
04502    if(verboseLevel > 1) {
04503      G4cout << " Transformation in Lab- System " << G4endl;
04504      for(i=0; i<vecLen; i++) pv[i].Print(i);
04505    }
04506 
04507   // G4bool dum(0);
04508   // DHW 19 May 2011: variable set but not used
04509 
04510   G4double ekin, teta;
04511 
04512   if (lead) {
04513     for (i = 0; i < vecLen; i++) {
04514       if (pv[i].getCode() == lead) {
04515 
04516         // dum = false;
04517         // DHW 19 May 2011: variable set but not used
04518 
04519         break;
04520       }
04521     }
04522     // At this point dum is always false, so the following code
04523     // cannot be executed.  For now, comment it out.
04524     /* 
04525     if (dum) {
04526       i = 0;          
04527  
04528       if ( ( (leadParticle.getType() == baryonType ||
04529               leadParticle.getType() == antiBaryonType)
04530             && (pv[1].getType() == baryonType ||
04531                 pv[1].getType() == antiBaryonType))
04532             || ( (leadParticle.getType() == mesonType)
04533               && (pv[1].getType() == mesonType))) {
04534         i = 1;
04535       }
04536 
04537       ekin = pv[i].getKineticEnergy();
04538       pv[i] = leadParticle;
04539       if (pv[i].getFlag() )
04540          pv[i].setTOF( -1.0 );
04541       else
04542           pv[i].setTOF( 1.0 );
04543       pv[i].setKineticEnergyAndUpdate( ekin );
04544     }
04545     */
04546   }
04547 
04548    pvmx[4].setMass( incidentMass);
04549    pvmx[4].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
04550    
04551    G4double ekin0 = pvmx[4].getKineticEnergy();
04552    
04553    pvmx[5].setMass ( protonMass * targ);
04554    pvmx[5].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
04555 
04556    ekin = pvmx[4].getEnergy() + pvmx[5].getEnergy();
04557 
04558    pvmx[6].Add( pvmx[4], pvmx[5] );
04559    pvmx[4].Lor( pvmx[4], pvmx[6] );
04560    pvmx[5].Lor( pvmx[5], pvmx[6] );
04561    
04562    G4double tecm = pvmx[4].getEnergy() + pvmx[5].getEnergy();
04563 
04564    pvmx[8].setZero();
04565    
04566    G4double ekin1 = 0.0;   
04567    
04568    for( i=0; i < vecLen; i++ ) 
04569       {
04570         pvmx[8].Add( pvmx[8], pv[i] );
04571         ekin1 += pv[i].getKineticEnergy();
04572         ekin  -= pv[i].getMass();
04573       }
04574    
04575    if( vecLen > 1 && vecLen < 19 ) 
04576      {
04577        constantCrossSection = true;
04578        G4HEVector pw[18];
04579        for(i=0;i<vecLen;i++) pw[i] = pv[i];
04580        wgt = NBodyPhaseSpace( tecm, constantCrossSection, pw, vecLen );
04581        ekin = 0.0;
04582        for( i=0; i < vecLen; i++ ) 
04583           {
04584             pvmx[7].setMass( pw[i].getMass());
04585             pvmx[7].setMomentum( pw[i].getMomentum() );
04586             pvmx[7].SmulAndUpdate( pvmx[7], 1.);
04587             pvmx[7].Lor( pvmx[7], pvmx[5] );
04588             ekin += pvmx[7].getKineticEnergy();
04589           }
04590        teta = pvmx[8].Ang( pvmx[4] );
04591        if (verboseLevel > 1) 
04592          G4cout << " vecLen > 1 && vecLen < 19 " << teta << " " << ekin0 
04593                 << " " << ekin1 << " " << ekin << G4endl;
04594      }
04595 
04596    if( ekin1 != 0.0 ) 
04597      {
04598        pvmx[7].setZero();
04599        wgt = ekin/ekin1;
04600        ekin1 = 0.;
04601        for( i=0; i < vecLen; i++ ) 
04602           {
04603             pvMass = pv[i].getMass();
04604             ekin   = pv[i].getKineticEnergy() * wgt;
04605             pv[i].setKineticEnergyAndUpdate( ekin );
04606             ekin1 += ekin;
04607             pvmx[7].Add( pvmx[7], pv[i] );
04608           }
04609        teta = pvmx[7].Ang( pvmx[4] );
04610        if (verboseLevel > 1) 
04611          G4cout << " ekin1 != 0 " << teta << " " << ekin0 << " " 
04612                 << ekin1 << G4endl;
04613      }
04614 
04615    // Do some smearing in the transverse direction due to Fermi motion.
04616 
04617    G4double ry   = G4UniformRand();
04618    G4double rz   = G4UniformRand();
04619    G4double rx   = twopi*rz;
04620    G4double a1   = std::sqrt(-2.0*std::log(ry));
04621    G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
04622    G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
04623 
04624    for (i = 0; i < vecLen; i++)
04625      pv[i].setMomentum( pv[i].getMomentum().x()+rantarg1,
04626                         pv[i].getMomentum().y()+rantarg2 );
04627 
04628    if (verboseLevel > 1) {
04629      pvmx[7].setZero();
04630      for (i = 0; i < vecLen; i++) pvmx[7].Add( pvmx[7], pv[i] );  
04631      teta = pvmx[7].Ang( pvmx[4] );   
04632      G4cout << " After smearing " << teta << G4endl;
04633    }
04634 
04635   // Rotate in the direction of the primary particle momentum (z-axis).
04636   // This does disturb our inclusive distributions somewhat, but it is 
04637   // necessary for momentum conservation.
04638 
04639   // Also subtract binding energies and make some further corrections 
04640   // if required.
04641 
04642   G4double dekin = 0.0;
04643   G4int npions = 0;    
04644   G4double ek1 = 0.0;
04645   G4double alekw, xxh;
04646   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
04647   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00};
04648   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65}; 
04649 
04650   for (i = 0; i < vecLen; i++) { 
04651     pv[i].Defs1( pv[i], pvI );
04652     if (atomicWeight > 1.5) {
04653       ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
04654       alekw = std::log( incidentKineticEnergy );
04655       xxh = 1.;
04656       xxh = 1.;
04657       if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
04658         if (pv[i].getCode() == pionZeroCode) {
04659           if (G4UniformRand() < std::log(atomicWeight)) {
04660             if (alekw > alem[0]) {
04661               G4int jmax = 1;
04662               for (j = 1; j < 8; j++) {
04663                 if (alekw < alem[j]) {
04664                   jmax = j;
04665                   break;
04666                 }
04667               } 
04668               xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
04669                    + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
04670               xxh = 1. - xxh;
04671             }
04672           }      
04673         }
04674       }  
04675       dekin += ekin*(1.-xxh);
04676       ekin *= xxh;
04677       pv[i].setKineticEnergyAndUpdate( ekin );
04678       pvCode = pv[i].getCode();
04679       if ((pvCode == pionPlusCode) ||
04680           (pvCode == pionMinusCode) ||
04681           (pvCode == pionZeroCode)) {
04682         npions += 1;
04683         ek1 += ekin; 
04684       }
04685     }
04686   }
04687 
04688    if( (ek1 > 0.0) && (npions > 0) ) 
04689       {
04690         dekin = 1.+dekin/ek1;
04691         for (i = 0; i < vecLen; i++)
04692           {
04693             pvCode = pv[i].getCode();
04694             if((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode)) 
04695               {
04696                 ekin = Amax( 1.0e-6, pv[i].getKineticEnergy() * dekin );
04697                 pv[i].setKineticEnergyAndUpdate( ekin );
04698               }
04699           }
04700       }
04701    if (verboseLevel > 1)
04702       { G4cout << " Lab-System " << ek1 << " " << npions << G4endl;
04703         for (i=0; i<vecLen; i++) pv[i].Print(i);
04704       }
04705 
04706    // Add black track particles
04707    // The total number of particles produced is restricted to 198
04708    // this may have influence on very high energies
04709 
04710    if (verboseLevel > 1) 
04711      G4cout << " Evaporation " <<  atomicWeight << " " 
04712             << excitationEnergyGNP << " " << excitationEnergyDTA << G4endl;
04713 
04714    if( atomicWeight > 1.5 ) 
04715      {
04716 
04717        G4double sprob, cost, sint, ekin2, ran, pp, eka;
04718        G4int spall(0), nbl(0);
04719        //  sprob is the probability of self-absorption in heavy molecules
04720 
04721        if( incidentKineticEnergy < 5.0 )
04722          sprob = 0.0;
04723        else
04724 //         sprob = Amin( 1.0, 0.6*std::log(incidentKineticEnergy-4.0) );
04725          sprob = Amin(1., 0.000314*atomicWeight*std::log(incidentKineticEnergy-4.)); 
04726        // First add protons and neutrons
04727 
04728        if( excitationEnergyGNP >= 0.001 ) 
04729          {
04730            //  nbl = number of proton/neutron black track particles
04731            //  tex is their total kinetic energy (GeV)
04732        
04733            nbl = Poisson( (1.5+1.25*targ)*excitationEnergyGNP/
04734                                     (excitationEnergyGNP+excitationEnergyDTA));
04735            if( targ+nbl > atomicWeight ) nbl = (int)(atomicWeight - targ);
04736            if (verboseLevel > 1) 
04737              G4cout << " evaporation " << targ << " " << nbl << " " 
04738                                        << sprob << G4endl; 
04739            spall = targ;
04740            if( nbl > 0) 
04741              {
04742                ekin = excitationEnergyGNP/nbl;
04743                ekin2 = 0.0;
04744                for( i=0; i<nbl; i++ ) 
04745                   {
04746                     if( G4UniformRand() < sprob ) continue;
04747                     if( ekin2 > excitationEnergyGNP) break;
04748                     ran = G4UniformRand();
04749                     ekin1 = -ekin*std::log(ran) - cfa*(1.0+0.5*normal());
04750                     if (ekin1 < 0) ekin1 = -0.010*std::log(ran);
04751                     ekin2 += ekin1;
04752                     if( ekin2 > excitationEnergyGNP )
04753                     ekin1 = Amax( 1.0e-6, excitationEnergyGNP-(ekin2-ekin1) );
04754                     if( G4UniformRand() > (1.0-atomicNumber/(atomicWeight)))
04755                        pv[vecLen].setDefinition( "Proton");
04756                     else
04757                        pv[vecLen].setDefinition( "Neutron");
04758                     spall++;
04759                     cost = G4UniformRand() * 2.0 - 1.0;
04760                     sint = std::sqrt(std::fabs(1.0-cost*cost));
04761                     phi = twopi * G4UniformRand();
04762                     pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
04763                     pv[vecLen].setSide( -4 );
04764                     pvMass = pv[vecLen].getMass();
04765                     pv[vecLen].setTOF( 1.0 );
04766                     pvEnergy = ekin1 + pvMass;
04767                     pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
04768                     pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
04769                                                      pp*sint*std::cos(phi),
04770                                                      pp*cost );
04771                     if (verboseLevel > 1) pv[vecLen].Print(vecLen);
04772                     vecLen++;
04773                   }
04774                if( (atomicWeight >= 10.0 ) && (incidentKineticEnergy <= 2.0) ) 
04775                   {
04776                     G4int ika, kk = 0;
04777                     eka = incidentKineticEnergy;
04778                     if( eka > 1.0 )eka *= eka;
04779                     eka = Amax( 0.1, eka );
04780                     ika = G4int(3.6*std::exp((atomicNumber*atomicNumber
04781                                 /atomicWeight-35.56)/6.45)/eka);
04782                     if( ika > 0 ) 
04783                       {
04784                         for( i=(vecLen-1); i>=0; i-- ) 
04785                            {
04786                              if( (pv[i].getCode() == protonCode) && pv[i].getFlag() ) 
04787                                {
04788                                  G4HEVector pTemp = pv[i];
04789                                  pv[i].setDefinition( "Neutron");
04790                                  pv[i].setMomentumAndUpdate(pTemp.getMomentum());
04791                                  if (verboseLevel > 1) pv[i].Print(i);
04792                                  if( ++kk > ika ) break;
04793                                }
04794                            }
04795                       }
04796                   }
04797              }
04798          }
04799 
04800      // Finished adding proton/neutron black track particles
04801      // now, try to add deuterons, tritons and alphas
04802      
04803      if( excitationEnergyDTA >= 0.001 ) 
04804        {
04805          nbl = Poisson( (1.5+1.25*targ)*excitationEnergyDTA
04806                                       /(excitationEnergyGNP+excitationEnergyDTA));
04807        
04808          //  nbl is the number of deutrons, tritons, and alphas produced
04809        
04810          if( nbl > 0 ) 
04811            {
04812              ekin = excitationEnergyDTA/nbl;
04813              ekin2 = 0.0;
04814              for( i=0; i<nbl; i++ ) 
04815                 {
04816                   if( G4UniformRand() < sprob ) continue;
04817                   if( ekin2 > excitationEnergyDTA) break;
04818                   ran = G4UniformRand();
04819                   ekin1 = -ekin*std::log(ran)-cfa*(1.+0.5*normal());
04820                   if( ekin1 < 0.0 ) ekin1 = -0.010*std::log(ran);
04821                   ekin2 += ekin1;
04822                   if( ekin2 > excitationEnergyDTA)
04823                      ekin1 = Amax( 1.0e-6, excitationEnergyDTA-(ekin2-ekin1));
04824                   cost = G4UniformRand()*2.0 - 1.0;
04825                   sint = std::sqrt(std::fabs(1.0-cost*cost));
04826                   phi = twopi*G4UniformRand();
04827                   ran = G4UniformRand();
04828                   if( ran <= 0.60 ) 
04829                       pv[vecLen].setDefinition( "Deuteron");
04830                   else if (ran <= 0.90)
04831                       pv[vecLen].setDefinition( "Triton");
04832                   else
04833                       pv[vecLen].setDefinition( "Alpha");
04834                   spall += (int)(pv[vecLen].getMass() * 1.066);
04835                   if( spall > atomicWeight ) break;
04836                   pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
04837                   pv[vecLen].setSide( -4 );
04838                   pvMass = pv[vecLen].getMass();
04839                   pv[vecLen].setTOF( 1.0 );
04840                   pvEnergy = pvMass + ekin1;
04841                   pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
04842                   pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
04843                                                    pp*sint*std::cos(phi),
04844                                                    pp*cost );
04845                   if (verboseLevel > 1) pv[vecLen].Print(vecLen);
04846                   vecLen++;
04847                 }
04848             }
04849         }
04850     }
04851    if( centerOfMassEnergy <= (4.0+G4UniformRand()) ) 
04852      {
04853        for( i=0; i<vecLen; i++ ) 
04854          {
04855            G4double etb = pv[i].getKineticEnergy();
04856            if( etb >= incidentKineticEnergy ) 
04857               pv[i].setKineticEnergyAndUpdate( incidentKineticEnergy );
04858          }
04859      }
04860 
04861    // Calculate time delay for nuclear reactions
04862 
04863    G4double tof = incidentTOF;
04864    if(     (atomicWeight >= 1.5) && (atomicWeight <= 230.0) 
04865         && (incidentKineticEnergy <= 0.2) )
04866            tof -= 500.0 * std::exp(-incidentKineticEnergy /0.04) * std::log( G4UniformRand() );
04867    for ( i=0; i < vecLen; i++)     
04868      { 
04869        
04870        pv[i].setTOF ( tof );
04871 //       vec[i].SetTOF ( tof );
04872      }
04873 
04874    for(i=0; i<vecLen; i++)
04875    {
04876      if(pv[i].getName() == "KaonZero" || pv[i].getName() == "AntiKaonZero")
04877      {
04878        pvmx[0] = pv[i];
04879        if(G4UniformRand() < 0.5) pv[i].setDefinition("KaonZeroShort");
04880        else                    pv[i].setDefinition("KaonZeroLong");
04881        pv[i].setMomentumAndUpdate(pvmx[0].getMomentum());
04882      }
04883    } 
04884 
04885    successful = true;
04886    delete [] pvmx;
04887    delete [] tempV;
04888    return;
04889  }

G4double G4HEInelastic::NBodyPhaseSpace ( G4int  npart,
G4HEVector  pv[],
G4double  wmax,
G4double  wfcn,
G4int  maxtrial,
G4int  ntrial 
)

Definition at line 5639 of file G4HEInelastic.cc.

References G4HEVector::Add(), G4HEVector::Add3(), Alam(), Amax(), CalculatePhaseSpaceWeight(), G4cout, G4endl, G4UniformRand, G4HEVector::getEnergy(), G4HEVector::getMass(), G4HEVector::Length(), G4HEVector::Lor(), G4INCL::Math::pi, QuickSort(), G4HEVector::setEnergy(), G4HEVector::setMass(), G4HEVector::setMomentumAndUpdate(), G4HEVector::Smul(), and sqr().

05642  { ntrial = 0;
05643    G4double wps(0);
05644    while ( ntrial < maxtrial)
05645      { ntrial++;
05646        G4int i, j;
05647        G4int nrn = 3*(npart-2)-4;
05648        G4double *ranarr = new G4double[nrn];
05649        for (i=0;i<nrn;i++) ranarr[i]=G4UniformRand();
05650        G4int nrnp = npart-4;
05651        if(nrnp > 1) QuickSort( ranarr, 0 , nrnp-1 );
05652        G4HEVector pvcms;
05653        pvcms.Add(pv[0],pv[1]);
05654        pvcms.Smul( pvcms, -1.);
05655        G4double rm = 0.;
05656        for (i=2;i<npart;i++) rm += pv[i].getMass();
05657        G4double rm1 = pvcms.getMass() - rm;
05658        rm -= pv[2].getMass();
05659        wps = (npart-3)*std::pow(rm1/sqr(twopi), npart-4)/(4*pi*pvcms.getMass());
05660        for (i=3; (i=npart-1);i++) wps /= i-2; // @@@@@@@@@@ bug @@@@@@@@@
05661        G4double xxx = rm1/sqr(twopi);
05662        for (i=1; (i=npart-4); i++) wps /= xxx/i; // @@@@@@@@@@ bug @@@@@@@@@
05663        wps /= (4*pi*pvcms.getMass());
05664        G4double p2,cost,sint,phi;
05665        j = 1;
05666        while (j)
05667          { j++;
05668            rm -= pv[j+1].getMass();
05669            if(j == npart-2) break;
05670            G4double rmass = rm + rm1*ranarr[npart-j-1];
05671            p2 = Alam(sqr(pvcms.getMass()), sqr(pv[j].getMass()),
05672                      sqr(rmass))/(4.*sqr(pvcms.getMass()));
05673            cost = 1. - 2.*ranarr[npart+2*j-9];
05674            sint = std::sqrt(1.-cost*cost);
05675            phi  = twopi*ranarr[npart+2*j-8];
05676            p2   = std::sqrt( Amax(0., p2));
05677            wps *= p2;
05678            pv[j].setMomentumAndUpdate( p2*sint*std::sin(phi), p2*sint*std::cos(phi),p2*cost);
05679            pv[j].Lor(pv[j], pvcms);
05680            pvcms.Add3( pvcms, pv[j] );
05681            pvcms.setEnergy(pvcms.getEnergy()-pv[j].getEnergy());
05682            pvcms.setMass( std::sqrt(sqr(pvcms.getEnergy()) - sqr(pvcms.Length())));
05683          }        
05684        p2 = Alam(sqr(pvcms.getMass()), sqr(pv[j].getMass()),
05685                  sqr(rm))/(4.*sqr(pvcms.getMass()));
05686        cost = 1. - 2.*ranarr[npart+2*j-9];
05687        sint = std::sqrt(1.-cost*cost);
05688        phi  = twopi*ranarr[npart+2*j-8];
05689        p2   = std::sqrt( Amax(0. , p2));
05690        wps *= p2;
05691        pv[j].setMomentumAndUpdate( p2*sint*std::sin(phi), p2*sint*std::cos(phi), p2*cost);
05692        pv[j+1].setMomentumAndUpdate( -p2*sint*std::sin(phi), -p2*sint*std::cos(phi), -p2*cost);
05693        pv[j].Lor( pv[j], pvcms );
05694        pv[j+1].Lor( pv[j+1], pvcms );
05695        wfcn = CalculatePhaseSpaceWeight( npart );
05696        G4double wt = wps * wfcn;
05697        if (wt > wmax)
05698          { wmax = wt;
05699            G4cout << "maximum weight changed to " << wmax << G4endl;
05700          }
05701        wt = wt/wmax;
05702        if (G4UniformRand() < wt) break; 
05703      }
05704    return wps;
05705  }

G4double G4HEInelastic::NBodyPhaseSpace ( const G4double  totalEnergy,
const G4bool  constantCrossSection,
G4HEVector  pv[],
G4int vecLen 
)

Definition at line 5423 of file G4HEInelastic.cc.

References Amax(), Amin(), Factorial(), FLT_MAX, G4cerr, G4cout, G4endl, G4UniformRand, G4INCL::Math::pi, G4InuclParticleNames::s0, G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMomentum(), G4InuclParticleNames::sm, sqr(), and verboseLevel.

Referenced by HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), and MediumEnergyClusterProduction().

05427 {
05428   // derived from original FORTRAN code PHASP by H. Fesefeldt (02-Dec-1986)
05429   // Returns the weight of the event
05430   G4int i;
05431     
05432   const G4double expxu =  std::log(FLT_MAX);  // upper bound for arg. of exp
05433   const G4double expxl = -expxu;         // lower bound for arg. of exp
05434     
05435   if( vecLen < 2 ) {
05436       G4cerr << "*** Error in G4HEInelastic::GenerateNBodyEvent" << G4endl;
05437       G4cerr << "    number of particles < 2" << G4endl;
05438       G4cerr << "totalEnergy = " << totalEnergy << ", vecLen = " 
05439              << vecLen << G4endl;
05440       return -1.0;
05441   }
05442     
05443   G4double* mass = new G4double [vecLen];    // mass of each particle
05444   G4double* energy = new G4double [vecLen];  // total energy of each particle
05445   G4double** pcm;           // pcm is an array with 3 rows and vecLen columns
05446   pcm = new G4double* [3];
05447   for( i=0; i<3; ++i )pcm[i] = new G4double [vecLen];
05448     
05449   G4double totalMass = 0.0;
05450   G4double* sm = new G4double [vecLen];
05451     
05452   for( i=0; i<vecLen; ++i ) {
05453       mass[i] = vec[i].getMass();
05454       vec[i].setMomentum( 0.0, 0.0, 0.0 );
05455       pcm[0][i] = 0.0;      // x-momentum of i-th particle
05456       pcm[1][i] = 0.0;      // y-momentum of i-th particle
05457       pcm[2][i] = 0.0;      // z-momentum of i-th particle
05458       energy[i] = mass[i];  // total energy of i-th particle
05459       totalMass += mass[i];
05460       sm[i] = totalMass;
05461   }
05462 
05463   if (totalMass >= totalEnergy ) {
05464       if (verboseLevel > 1) {
05465         G4cout << "*** Error in G4HEInelastic::GenerateNBodyEvent" << G4endl;
05466         G4cout << "    total mass (" << totalMass << ") >= total energy ("
05467                << totalEnergy << ")" << G4endl;
05468       }
05469       delete [] mass;
05470       delete [] energy;
05471       for( i=0; i<3; ++i )delete [] pcm[i];
05472       delete [] pcm;
05473       delete [] sm;
05474       return -1.0;
05475   }
05476 
05477   G4double kineticEnergy = totalEnergy - totalMass;
05478   G4double* emm = new G4double [vecLen];
05479   emm[0] = mass[0];
05480   if (vecLen > 3) {          // the random numbers are sorted
05481       G4double* ran = new G4double [vecLen];
05482       for( i=0; i<vecLen; ++i )ran[i] = G4UniformRand();
05483       for( i=0; i<vecLen-1; ++i ) {
05484         for( G4int j=vecLen-1; j > i; --j ) {
05485           if( ran[i] > ran[j] ) {
05486             G4double temp = ran[i];
05487             ran[i] = ran[j];
05488             ran[j] = temp;
05489           }
05490         }
05491       }
05492       for( i=1; i<vecLen; ++i )emm[i] = ran[i-1]*kineticEnergy + sm[i];
05493       delete [] ran;
05494   } else {
05495     emm[1] = G4UniformRand()*kineticEnergy + sm[1];
05496   }
05497 
05498   emm[vecLen-1] = totalEnergy;
05499     
05500   // Weight is the sum of logarithms of terms instead of the product of terms
05501     
05502   G4bool lzero = true;    
05503   G4double wtmax = 0.0;
05504   if (constantCrossSection) {     // this is KGENEV=1 in PHASP
05505       G4double emmax = kineticEnergy + mass[0];
05506       G4double emmin = 0.0;
05507       for( i=1; i<vecLen; ++i ) {
05508         emmin += mass[i-1];
05509         emmax += mass[i];
05510         G4double wtfc = 0.0;
05511         if( emmax*emmax > 0.0 ) {
05512           G4double arg = emmax*emmax
05513             + (emmin*emmin-mass[i]*mass[i])*(emmin*emmin-mass[i]*mass[i])/(emmax*emmax)
05514             - 2.0*(emmin*emmin+mass[i]*mass[i]);
05515           if( arg > 0.0 )wtfc = 0.5*std::sqrt( arg );
05516         }
05517         if( wtfc == 0.0 ) {
05518           lzero = false;
05519           break;
05520         }
05521         wtmax += std::log( wtfc );
05522       }
05523       if( lzero )
05524         wtmax = -wtmax;
05525       else
05526         wtmax = expxu;
05527     } else {
05528       wtmax = std::log( std::pow( kineticEnergy, vecLen-2 ) *
05529                    pi * std::pow( twopi, vecLen-2 ) / Factorial(vecLen-2) );
05530     }
05531     lzero = true;
05532     G4double* pd = new G4double [vecLen-1];
05533     for( i=0; i<vecLen-1; ++i ) {
05534       pd[i] = 0.0;
05535       if( emm[i+1]*emm[i+1] > 0.0 ) {
05536         G4double arg = emm[i+1]*emm[i+1]
05537           + (emm[i]*emm[i]-mass[i+1]*mass[i+1])*(emm[i]*emm[i]-mass[i+1]*mass[i+1])
05538             /(emm[i+1]*emm[i+1])
05539           - 2.0*(emm[i]*emm[i]+mass[i+1]*mass[i+1]);
05540         if( arg > 0.0 )pd[i] = 0.5*std::sqrt( arg );
05541       }
05542       if( pd[i] == 0.0 )
05543         lzero = false;
05544       else
05545         wtmax += std::log( pd[i] );
05546     }
05547     G4double weight = 0.0;        // weight is returned by GenerateNBodyEvent
05548     if( lzero )weight = std::exp( Amax(Amin(wtmax,expxu),expxl) );
05549     
05550     G4double bang, cb, sb, s0, s1, s2, c, esys, a, b, gama, beta;
05551     G4double ss;
05552     pcm[0][0] = 0.0;
05553     pcm[1][0] = pd[0];
05554     pcm[2][0] = 0.0;
05555     for( i=1; i<vecLen; ++i ) {
05556       pcm[0][i] = 0.0;
05557       pcm[1][i] = -pd[i-1];
05558       pcm[2][i] = 0.0;
05559       bang = twopi*G4UniformRand();
05560       cb = std::cos(bang);
05561       sb = std::sin(bang);
05562       c = 2.0*G4UniformRand() - 1.0;
05563       ss = std::sqrt( std::fabs( 1.0-c*c ) );
05564       if( i < vecLen-1 ) {
05565         esys = std::sqrt(pd[i]*pd[i] + emm[i]*emm[i]);
05566         beta = pd[i]/esys;
05567         gama = esys/emm[i];
05568         for( G4int j=0; j<=i; ++j ) {
05569           s0 = pcm[0][j];
05570           s1 = pcm[1][j];
05571           s2 = pcm[2][j];
05572           energy[j] = std::sqrt( s0*s0 + s1*s1 + s2*s2 + mass[j]*mass[j] );
05573           a = s0*c - s1*ss;                           //  rotation
05574           pcm[1][j] = s0*ss + s1*c;
05575           b = pcm[2][j];
05576           pcm[0][j] = a*cb - b*sb;
05577           pcm[2][j] = a*sb + b*cb;
05578           pcm[1][j] = gama*(pcm[1][j] + beta*energy[j]);
05579         }
05580       } else {
05581         for( G4int j=0; j<=i; ++j ) {
05582           s0 = pcm[0][j];
05583           s1 = pcm[1][j];
05584           s2 = pcm[2][j];
05585           energy[j] = std::sqrt( s0*s0 + s1*s1 + s2*s2 + mass[j]*mass[j] );
05586           a = s0*c - s1*ss;                           //  rotation
05587           pcm[1][j] = s0*ss + s1*c;
05588           b = pcm[2][j];
05589           pcm[0][j] = a*cb - b*sb;
05590           pcm[2][j] = a*sb + b*cb;
05591         }
05592       }
05593   }
05594 
05595   G4double pModule; 
05596   for (i = 0; i < vecLen; ++i) {
05597     kineticEnergy = energy[i] - mass[i];
05598     pModule = std::sqrt( sqr(kineticEnergy) + 2*kineticEnergy*mass[i] );    
05599     vec[i].setMomentum(pcm[0][i]/pModule, 
05600                        pcm[1][i]/pModule, 
05601                        pcm[2][i]/pModule);
05602     vec[i].setKineticEnergyAndUpdate( kineticEnergy );
05603   }
05604 
05605   delete [] mass;
05606   delete [] energy;
05607   for( i=0; i<3; ++i )delete [] pcm[i];
05608   delete [] pcm;
05609   delete [] emm;
05610   delete [] sm;
05611   delete [] pd;
05612   return weight;
05613 }

G4double G4HEInelastic::normal ( void   ) 

Definition at line 259 of file G4HEInelastic.cc.

References G4UniformRand.

Referenced by HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), NuclearExcitation(), Poisson(), and QuasiElasticScattering().

00260  {
00261    G4double ran = -6.0;
00262    for(G4int i=0; i<12; i++) ran += G4UniformRand();
00263    return ran;
00264  }

G4double G4HEInelastic::NuclearExcitation ( G4double  incidentKineticEnergy,
G4double  atomicWeight,
G4double  atomicNumber,
G4double excitationEnergyCascade,
G4double excitationEnergyEvaporation 
)

Definition at line 179 of file G4HEInelastic.cc.

References Amax(), Amin(), G4cout, G4endl, G4HEVector::getMass(), Neutron, normal(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), G4HEAntiKaonZeroInelastic::ApplyYourself(), HighEnergyCascading(), and MediumEnergyCascading().

00184   {
00185     G4double neutronMass  = Neutron.getMass();
00186     G4double electronMass = 0.000511;
00187     G4double exnu         = 0.; 
00188     excitationEnergyGPN   = 0.;
00189     excitationEnergyDTA   = 0.;
00190 
00191     if (atomicWeight > (neutronMass + 2.*electronMass))
00192        {
00193          G4int    magic = ((G4int)(atomicNumber+0.1) == 82) ? 1 : 0;
00194          G4double ekin  = Amin(Amax(incidentKineticEnergy, 0.1), 4.);
00195          G4double cfa   = Amax(0.35 +((0.35 - 0.05)/2.3)*std::log(ekin), 0.15);
00196                   exnu  = 7.716*cfa*std::exp(-cfa);
00197          G4double atno  = Amin(atomicWeight, 120.);
00198                   cfa   = ((atno - 1.)/120.) * std::exp(-(atno-1.)/120.);
00199                   exnu  = exnu * cfa;
00200          G4double fpdiv = Amax(1.-0.25*ekin*ekin, 0.5);
00201          G4double gfa   = 2.*((atomicWeight-1.)/70.) 
00202                             * std::exp(-(atomicWeight-1.)/70.);
00203 
00204          excitationEnergyGPN = exnu * fpdiv;
00205          excitationEnergyDTA = exnu - excitationEnergyGPN;  
00206         
00207          G4double ran1 = 0., ran2 = 0.;
00208          if (!magic)
00209             { ran1 = normal();
00210               ran2 = normal();
00211             }
00212          excitationEnergyGPN = Amax(excitationEnergyGPN*(1.+ran1*gfa),0.);
00213          excitationEnergyDTA = Amax(excitationEnergyDTA*(1.+ran2*gfa),0.);
00214          exnu = excitationEnergyGPN + excitationEnergyDTA;
00215          if(verboseLevel > 1) {
00216            G4cout << " NuclearExcitation: " << magic << " " <<  ekin 
00217                   << " " << cfa << " " <<  atno << " " << fpdiv << " " 
00218                   <<  gfa << " " << excitationEnergyGPN
00219                   << " " <<  excitationEnergyDTA << G4endl;
00220          } 
00221 
00222          while (exnu >= incidentKineticEnergy)
00223             {
00224               excitationEnergyGPN *= (1. - 0.5*normal());
00225               excitationEnergyDTA *= (1. - 0.5*normal());
00226               exnu = excitationEnergyGPN + excitationEnergyDTA;
00227             }
00228        }             
00229     return exnu;
00230   }     

G4double G4HEInelastic::NuclearInelasticity ( G4double  incidentKineticEnergy,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 149 of file G4HEInelastic.cc.

References Amax(), Amin(), G4cout, G4endl, and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

00152   {
00153     G4double expu = 82.;
00154     G4double expl = -expu;
00155     G4double ala    = std::log(atomicWeight);
00156     G4double ale    = std::log(incidentKineticEnergy);
00157     G4double sig1   = 0.5;
00158     G4double sig2   = 0.5;
00159     G4double em     = Amin(0.239 + 0.0408*ala*ala, 1.);
00160     G4double cinem  = Amin(0.0019*std::pow(ala,3.), 0.15);
00161     G4double sig    = (ale > em) ? sig2 : sig1; 
00162     G4double corr   = Amin(Amax(-std::pow(ale-em,2.)/(2.*sig*sig),expl), expu);
00163     G4double dum1   = -(incidentKineticEnergy)*cinem;
00164     G4double dum2   = std::abs(dum1);
00165     G4double dum3   = std::exp(corr);
00166     G4double cinema = 0.;
00167     if (dum2 >= 1.)           cinema = dum1*dum3;
00168     else if (dum3 > 1.e-10) cinema = dum1*dum3;    
00169     cinema = - Amax(-incidentKineticEnergy, cinema);
00170     if(verboseLevel > 1) {
00171       G4cout << " NuclearInelasticity: " << ala << " " <<  ale << " "  
00172              << em << " " << corr << " " <<  dum1 << " "  << dum2 << " " 
00173              <<  dum3 << " " <<  cinema << G4endl;
00174     }                 
00175     return cinema;
00176   }

G4double G4HEInelastic::pmltpc ( G4int  np,
G4int  nm,
G4int  nz,
G4int  n,
G4double  b,
G4double  c 
)

Definition at line 233 of file G4HEInelastic.cc.

References Amax(), and Amin().

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), and G4HEXiZeroInelastic::FirstIntInCasXiZero().

00235  { 
00236    G4double expxu = 82.;
00237    G4double expxl = -expxu;
00238    G4int i;
00239    G4double npf = 0.0, nmf = 0.0, nzf = 0.0;
00240    for(i=2;i<=npos;i++) npf += std::log((G4double)i);
00241    for(i=2;i<=nneg;i++) nmf += std::log((G4double)i);
00242    for(i=2;i<=nzero;i++) nzf += std::log((G4double)i);
00243    G4double r = Amin(expxu,Amax(expxl,
00244                                -(npos-nneg+nzero+b)*(npos-nneg+nzero+b)/(2*c*c*n*n)-npf-nmf-nzf));
00245    return std::exp(r);
00246  }

G4int G4HEInelastic::Poisson ( G4double  x  ) 

Definition at line 267 of file G4HEInelastic.cc.

References Amax(), Factorial(), G4UniformRand, and normal().

Referenced by HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), and QuasiElasticScattering().

00268 {
00269   G4int i, iran = 0;
00270   G4double ran;
00271   if (x > 9.9) {
00272     iran = G4int( Amax( 0.0, x + normal() * std::sqrt( x ) ) );
00273   } else {
00274     G4int fivex = G4int(5.0 * x);
00275     if (fivex <= 0) {
00276       G4double p1 = x * std::exp( -x );
00277       G4double p2 = x * p1/2.;
00278       G4double p3 = x * p2/3.;
00279       ran = G4UniformRand();
00280       if (ran < p3) iran = 3;
00281       else if ( ran < p2 ) iran = 2;
00282       else if ( ran < p1 ) iran = 1;
00283     } else {
00284       G4double r = std::exp(-x);
00285       ran = G4UniformRand();
00286       if (ran > r) {
00287         G4double rrr;
00288         G4double rr = r;
00289         for (i = 1; i <= fivex; i++) {
00290           iran++;
00291           if (i > 5) rrr = std::exp(i*std::log(x)-(i+0.5)*std::log((G4double)i)+i-0.9189385);
00292           else rrr = std::pow(x,i)*Factorial(i);
00293           rr += r * rrr;
00294           if (ran <= rr) break;
00295         }
00296       }         
00297     }
00298   }
00299   return iran;
00300 }

void G4HEInelastic::QuasiElasticScattering ( G4bool successful,
G4HEVector  pv[],
G4int vecLen,
G4double excitationEnergyGNP,
G4double excitationEnergyDTA,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 4892 of file G4HEInelastic.cc.

References G4HEVector::Add(), Amax(), Amin(), AntiProton, G4HEVector::Defs1(), G4cout, G4endl, G4UniformRand, G4HEVector::getCode(), G4HEVector::getEnergy(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getMomentum(), G4HEVector::getTotalMomentum(), G4HEVector::getType(), G4HEVector::Length(), G4HEVector::Lor(), normal(), PionPlus, Poisson(), G4InuclParticleNames::pp, G4HEVector::Print(), Proton, G4HEVector::setDefinition(), G4HEVector::setFlag(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setSide(), G4HEVector::setTOF(), G4HEVector::SmulAndUpdate(), sqr(), and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

04901 {
04902   // if the Cascading or Resonance - model fails, we try this,
04903   // QuasiElasticScattering. 
04904   //    
04905   //  All quantities on the G4HEVector Array pv are in GeV- units.
04906 
04907   G4int protonCode = Proton.getCode();
04908   G4String mesonType = PionPlus.getType();
04909   G4String baryonType = Proton.getType(); 
04910   G4String antiBaryonType = AntiProton.getType(); 
04911    
04912   G4double targetMass = targetParticle.getMass();
04913   G4double incidentMass = incidentParticle.getMass();
04914   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
04915   G4double incidentEnergy = incidentParticle.getEnergy();
04916   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
04917   G4String incidentType = incidentParticle.getType();
04918 //   G4double incidentTOF           = incidentParticle.getTOF();   
04919   G4double incidentTOF = 0.;
04920    
04921   // some local variables
04922   G4int i;
04923    
04924   if (verboseLevel > 1) 
04925     G4cout << " G4HEInelastic::QuasiElasticScattering " << G4endl;
04926 
04927   if (incidentTotalMomentum < 0.01 || vecLen < 2) {
04928     successful = false;
04929     return;
04930   }
04931 
04932   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
04933                                         +2.*targetMass*incidentEnergy);
04934 
04935   G4HEVector pvI = incidentParticle;  // for the incident particle
04936   pvI.setSide( 1 );
04937 
04938   G4HEVector pvT = targetParticle;   // for the target particle
04939   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
04940   pvT.setSide( -1 );
04941   pvT.setTOF( -1.); 
04942 
04943   G4HEVector* pvmx = new G4HEVector[3];
04944 
04945   if (atomicWeight > 1.5) { 
04946     // for the following case better use ElasticScattering
04947     if (   (pvI.getCode() == pv[0].getCode() )
04948         && (pvT.getCode() == pv[1].getCode() )
04949         && (excitationEnergyGNP < 0.001)
04950         && (excitationEnergyDTA < 0.001) ) {
04951       successful = false;
04952       delete [] pvmx;
04953       return;
04954     }
04955   }
04956 
04957   pv[0].setSide( 1 );
04958   pv[0].setFlag( false );
04959   pv[0].setTOF( incidentTOF);
04960   pv[0].setMomentumAndUpdate( incidentParticle.getMomentum() );
04961   pv[1].setSide( -1 );
04962   pv[1].setFlag( false );
04963   pv[1].setTOF( incidentTOF);
04964   pv[1].setMomentumAndUpdate(targetParticle.getMomentum() );
04965 
04966   if ((incidentTotalMomentum > 0.1) && (centerOfMassEnergy > 0.01) ) {
04967     if (pv[1].getType() == mesonType) {
04968       if (G4UniformRand() < 0.5)
04969         pv[1].setDefinition( "Proton"); 
04970       else
04971         pv[1].setDefinition( "Neutron");
04972     }
04973     pvmx[0].Add( pvI, pvT );
04974     pvmx[1].Lor( pvI, pvmx[0] );
04975     pvmx[2].Lor( pvT, pvmx[0] );
04976     G4double pin = pvmx[1].Length();
04977     G4double bvalue = Amax(0.01 , 4.225+1.795*std::log(incidentTotalMomentum));
04978     G4double pf = sqr(sqr(centerOfMassEnergy) + sqr(pv[1].getMass()) - sqr(pv[0].getMass()))
04979                   - 4 * sqr(centerOfMassEnergy) * sqr(pv[1].getMass());
04980 
04981     if (pf < 0.001) {
04982       successful = false;
04983       delete [] pvmx;
04984       return;
04985     }
04986     pf = std::sqrt(pf)/(2.*centerOfMassEnergy);
04987     G4double btrang = 4. * bvalue * pin * pf;
04988     G4double exindt = -1.;
04989     if (btrang < 46.) exindt += std::exp(-btrang);
04990     G4double tdn = std::log(1. + G4UniformRand()*exindt)/btrang;
04991     G4double ctet = Amax( -1., Amin(1., 1. + 2.*tdn));
04992     G4double stet = std::sqrt((1.-ctet)*(1.+ctet));
04993     G4double phi  = twopi * G4UniformRand();
04994     pv[0].setMomentumAndUpdate( pf*stet*std::sin(phi),
04995                                 pf*stet*std::cos(phi),
04996                                 pf*ctet         );
04997     pv[1].SmulAndUpdate( pv[0], -1.); 
04998     for (i = 0; i < 2; i++) {
04999       // **  pv[i].Lor( pv[i], pvmx[4] );
05000       // ** DHW 1 Dec 2010 : index 4 out of range : use 0
05001       pv[i].Lor(pv[i], pvmx[0]);
05002       pv[i].Defs1(pv[i], pvI);
05003       if (atomicWeight > 1.5) {
05004         G4double ekin = pv[i].getKineticEnergy() 
05005                      -  0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.)
05006                        *(1. + 0.5*normal()); 
05007         ekin = Amax(0.0001, ekin);
05008         pv[i].setKineticEnergyAndUpdate( ekin );
05009       }
05010     }
05011   }
05012   vecLen = 2;
05013 
05014   //  add black track particles
05015   //  the total number of particles produced is restricted to 198
05016   //  this may have influence on very high energies
05017 
05018   if (verboseLevel > 1) 
05019     G4cout << " Evaporation " << atomicWeight << " "
05020            << excitationEnergyGNP << " " <<  excitationEnergyDTA << G4endl;
05021 
05022    if( atomicWeight > 1.5 ) 
05023      {
05024 
05025        G4double sprob, cost, sint, ekin2, ran, pp, eka;
05026        G4double ekin, cfa, ekin1, phi, pvMass, pvEnergy;
05027        G4int spall(0), nbl(0);
05028        //  sprob is the probability of self-absorption in heavy molecules
05029 
05030        sprob = 0.;
05031        cfa   = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
05032                                      //  first add protons and neutrons
05033 
05034        if( excitationEnergyGNP >= 0.001 ) 
05035          {
05036            //  nbl = number of proton/neutron black track particles
05037            //  tex is their total kinetic energy (GeV)
05038        
05039            nbl = Poisson( excitationEnergyGNP/0.02);
05040            if( nbl > atomicWeight ) nbl = (int)(atomicWeight);
05041            if (verboseLevel > 1) 
05042              G4cout << " evaporation " << nbl << " " << sprob << G4endl; 
05043            spall = 0;
05044            if( nbl > 0) 
05045              {
05046                ekin = excitationEnergyGNP/nbl;
05047                ekin2 = 0.0;
05048                for( i=0; i<nbl; i++ ) 
05049                   {
05050                     if( G4UniformRand() < sprob ) continue;
05051                     if( ekin2 > excitationEnergyGNP) break;
05052                     ran = G4UniformRand();
05053                     ekin1 = -ekin*std::log(ran) - cfa*(1.0+0.5*normal());
05054                     if (ekin1 < 0) ekin1 = -0.010*std::log(ran);
05055                     ekin2 += ekin1;
05056                     if( ekin2 > excitationEnergyGNP)
05057                     ekin1 = Amax( 1.0e-6, excitationEnergyGNP-(ekin2-ekin1) );
05058                     if( G4UniformRand() > (1.0-atomicNumber/(atomicWeight)))
05059                        pv[vecLen].setDefinition( "Proton");
05060                     else
05061                        pv[vecLen].setDefinition( "Neutron");
05062                     spall++;
05063                     cost = G4UniformRand() * 2.0 - 1.0;
05064                     sint = std::sqrt(std::fabs(1.0-cost*cost));
05065                     phi = twopi * G4UniformRand();
05066                     pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
05067                     pv[vecLen].setSide( -4 );
05068                     pvMass = pv[vecLen].getMass();
05069                     pv[vecLen].setTOF( 1.0 );
05070                     pvEnergy = ekin1 + pvMass;
05071                     pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
05072                     pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
05073                                                      pp*sint*std::cos(phi),
05074                                                      pp*cost );
05075                     if (verboseLevel > 1) pv[vecLen].Print(vecLen);
05076                     vecLen++;
05077                   }
05078                if( (atomicWeight >= 10.0 ) && (incidentKineticEnergy <= 2.0) ) 
05079                   {
05080                     G4int ika, kk = 0;
05081                     eka = incidentKineticEnergy;
05082                     if( eka > 1.0 )eka *= eka;
05083                     eka = Amax( 0.1, eka );
05084                     ika = G4int(3.6*std::exp((atomicNumber*atomicNumber
05085                                 /atomicWeight-35.56)/6.45)/eka);
05086                     if( ika > 0 ) 
05087                       {
05088                         for( i=(vecLen-1); i>=0; i-- ) 
05089                            {
05090                              if( (pv[i].getCode() == protonCode) && pv[i].getFlag() ) 
05091                                {
05092                                  pv[i].setDefinition( "Neutron" );
05093                                  if (verboseLevel > 1) pv[i].Print(i);
05094                                  if( ++kk > ika ) break;
05095                                }
05096                            }
05097                       }
05098                   }
05099              }
05100          }
05101 
05102      // finished adding proton/neutron black track particles
05103      //  now, try to add deuterons, tritons and alphas
05104      
05105      if( excitationEnergyDTA >= 0.001 ) 
05106        {
05107          nbl = (G4int)(2.*std::log(atomicWeight));
05108        
05109          //    nbl is the number of deutrons, tritons, and alphas produced
05110        
05111          if( nbl > 0 ) 
05112            {
05113              ekin = excitationEnergyDTA/nbl;
05114              ekin2 = 0.0;
05115              for( i=0; i<nbl; i++ ) 
05116                 {
05117                   if( G4UniformRand() < sprob ) continue;
05118                   if( ekin2 > excitationEnergyDTA) break;
05119                   ran = G4UniformRand();
05120                   ekin1 = -ekin*std::log(ran)-cfa*(1.+0.5*normal());
05121                   if( ekin1 < 0.0 ) ekin1 = -0.010*std::log(ran);
05122                   ekin2 += ekin1;
05123                   if( ekin2 > excitationEnergyDTA)
05124                      ekin1 = Amax( 1.0e-6, excitationEnergyDTA-(ekin2-ekin1));
05125                   cost = G4UniformRand()*2.0 - 1.0;
05126                   sint = std::sqrt(std::fabs(1.0-cost*cost));
05127                   phi = twopi*G4UniformRand();
05128                   ran = G4UniformRand();
05129                   if( ran <= 0.60 ) 
05130                       pv[vecLen].setDefinition( "Deuteron");
05131                   else if (ran <= 0.90)
05132                       pv[vecLen].setDefinition( "Triton");
05133                   else
05134                       pv[vecLen].setDefinition( "Alpha");
05135                   spall += (int)(pv[vecLen].getMass() * 1.066);
05136                   if( spall > atomicWeight ) break;
05137                   pv[vecLen].setFlag( true );  // true is the same as IPA(i)<0
05138                   pv[vecLen].setSide( -4 );
05139                   pvMass = pv[vecLen].getMass();
05140                   pv[vecLen].setTOF( 1.0 );
05141                   pvEnergy = pvMass + ekin1;
05142                   pp = std::sqrt( std::fabs( pvEnergy*pvEnergy - pvMass*pvMass ) );
05143                   pv[vecLen].setMomentumAndUpdate( pp*sint*std::sin(phi),
05144                                                    pp*sint*std::cos(phi),
05145                                                    pp*cost );
05146                   if (verboseLevel > 1) pv[vecLen].Print(vecLen);
05147                   vecLen++;
05148                 }
05149             }
05150         }
05151     }
05152 
05153    // Calculate time delay for nuclear reactions
05154 
05155    G4double tof = incidentTOF;
05156    if(     (atomicWeight >= 1.5) && (atomicWeight <= 230.0) 
05157         && (incidentKineticEnergy <= 0.2) )
05158            tof -= 500.0 * std::exp(-incidentKineticEnergy /0.04) * std::log( G4UniformRand() );
05159    for ( i=0; i < vecLen; i++)     
05160      { 
05161        
05162        pv[i].setTOF ( tof );
05163 //       vec[i].SetTOF ( tof );
05164      }
05165 
05166    for(i=0; i<vecLen; i++)
05167    {
05168      if(pv[i].getName() == "KaonZero" || pv[i].getName() == "AntiKaonZero")
05169      {
05170        pvmx[0] = pv[i];
05171        if(G4UniformRand() < 0.5) pv[i].setDefinition("KaonZeroShort");
05172        else                    pv[i].setDefinition("KaonZeroLong");
05173        pv[i].setMomentumAndUpdate(pvmx[0].getMomentum());
05174      }
05175    } 
05176 
05177   successful = true;
05178   delete [] pvmx;
05179   return;
05180 }

void G4HEInelastic::QuickSort ( G4double  arr[],
const G4int  lidx,
const G4int  ridx 
)

Definition at line 5709 of file G4HEInelastic.cc.

References buffer.

Referenced by NBodyPhaseSpace().

05710  {                         // sorts the Array arr[] in ascending order
05711    G4double buffer;
05712    G4int k, e, mid;
05713    if(lidx>=ridx) return;
05714    mid = (int)((lidx+ridx)/2.);
05715    buffer   = arr[lidx];
05716    arr[lidx]= arr[mid];
05717    arr[mid] = buffer;
05718    e = lidx;
05719    for (k=lidx+1;k<=ridx;k++)
05720      if (arr[k] < arr[lidx])
05721        { e++;
05722          buffer = arr[e];
05723          arr[e] = arr[k];
05724          arr[k] = buffer;
05725        }
05726    buffer   = arr[lidx];
05727    arr[lidx]= arr[e];
05728    arr[e]   = buffer;
05729    QuickSort(arr, lidx, e-1);
05730    QuickSort(arr, e+1 , ridx);
05731    return;
05732  }

G4int G4HEInelastic::rtmi ( G4double x,
G4double  xli,
G4double  xri,
G4double  eps,
G4int  iend,
G4double  aa,
G4double  bb,
G4double  cc,
G4double  dd,
G4double  rr 
)

Definition at line 5286 of file G4HEInelastic.cc.

References fctcos().

Referenced by ElasticScattering().

05290  {
05291    G4int ier = 0;
05292    G4double xl = xli;
05293    G4double xr = xri;
05294    *x = xl;
05295    G4double tol = *x;
05296    G4double f = fctcos(tol, aa, bb, cc, dd, rr);
05297    if (f == 0.) return ier;
05298    G4double fl, fr;
05299    fl = f;
05300    *x = xr;
05301    tol = *x;
05302    f = fctcos(tol, aa, bb, cc, dd, rr);
05303    if (f == 0.) return ier;
05304    fr = f;
05305 
05306    // Error return in case of wrong input data
05307    if (fl*fr >= 0.) 
05308      {
05309        ier = 2;
05310        return ier;
05311      }
05312 
05313    // Basic assumption fl*fr less than 0 is satisfied.
05314    // Generate tolerance for function values.
05315    G4int i = 0;
05316    G4double tolf = 100.*eps;
05317 
05318    // Start iteration loop
05319 
05320    label4:   // <-------------
05321    i++;
05322 
05323    // Start bisection loop
05324 
05325    for (G4int k = 1; k <= iend; k++) 
05326      {
05327        *x = 0.5*(xl + xr);
05328        tol = *x;
05329        f = fctcos(tol, aa, bb, cc, dd, rr);
05330        if (f == 0.) return 0;
05331        if (f*fr < 0.) 
05332          {                  // Interchange xl and xr in order to get the
05333            tol = xl;        // same sign in f and fr
05334            xl = xr;
05335            xr = tol;
05336            tol = fl;
05337            fl = fr;
05338            fr = tol;
05339          }
05340        tol = f - fl;
05341        G4double a = f*tol;
05342        a = a + a;
05343        if (a < fr*(fr - fl) && i <= iend) goto label17;
05344        xr = *x;
05345        fr = f;
05346 
05347        // Test on satisfactory accuracy in bisection loop
05348        tol = eps;
05349        a = std::fabs(xr);
05350        if (a > 1.) tol = tol*a;
05351        if (std::fabs(xr - xl) <= tol && std::fabs(fr - fl) <= tolf) goto label14;
05352      }
05353    // End of bisection loop
05354 
05355    // No convergence after iend iteration steps followed by iend
05356    // successive steps of bisection or steadily increasing function
05357    // values at right bounds.  Error return.
05358    ier = 1;
05359 
05360    label14:  // <---------------
05361    if (std::fabs(fr) > std::fabs(fl)) 
05362      {
05363        *x = xl;
05364        f = fl;
05365      }
05366    return ier;
05367 
05368    // Computation of iterated x-value by inverse parabolic interp
05369    label17:  // <---------------
05370    G4double a = fr - f;
05371    G4double dx = (*x - xl)*fl*(1. + f*(a - tol)/(a*(fr - fl)))/tol;
05372    G4double xm = *x;
05373    G4double fm = f;
05374    *x = xl - dx;
05375    tol = *x;
05376    f = fctcos(tol, aa, bb, cc, dd, rr);
05377    if (f == 0.) return ier;
05378 
05379    // Test on satisfactory accuracy in iteration loop
05380    tol = eps;
05381    a = std::fabs(*x);
05382    if (a > 1) tol = tol*a;
05383    if (std::fabs(dx) <= tol && std::fabs(f) <= tolf) return ier;
05384 
05385    // Preparation of next bisection loop
05386    if (f*fl < 0.) 
05387      {
05388        xr = *x;
05389        fr = f;
05390      }
05391    else 
05392      {
05393        xl = *x;
05394        fl = f;
05395        xr = xm;
05396        fr = fm;
05397      }
05398    goto label4;
05399  }

void G4HEInelastic::SetMaxNumberOfSecondaries ( const G4int  maxnumber  )  [inline]

Reimplemented in G4HEAntiSigmaZeroInelastic, and G4HESigmaZeroInelastic.

Definition at line 73 of file G4HEInelastic.hh.

References MAXPART.

Referenced by G4HESigmaZeroInelastic::ApplyYourself(), and G4HEAntiSigmaZeroInelastic::ApplyYourself().

00074             {MAXPART = maxnumber;}      

void G4HEInelastic::SetParticles ( void   ) 

Definition at line 82 of file G4HEInelastic.cc.

References Alpha, AntiKaonZero, AntiLambda, AntiNeutron, AntiOmegaMinus, AntiProton, AntiSigmaMinus, AntiSigmaPlus, AntiSigmaZero, AntiXiMinus, AntiXiZero, Deuteron, Gamma, KaonMinus, KaonPlus, KaonZero, KaonZeroLong, KaonZeroShort, Lambda, Neutron, OmegaMinus, PionMinus, PionPlus, PionZero, Proton, G4HEVector::setDefinition(), SigmaMinus, SigmaPlus, SigmaZero, Triton, XiMinus, and XiZero.

Referenced by G4HEInelastic().

00083 {
00084   PionPlus.setDefinition("PionPlus");
00085   PionZero.setDefinition("PionZero");
00086   PionMinus.setDefinition("PionMinus");
00087   KaonPlus.setDefinition("KaonPlus");
00088   KaonZero.setDefinition("KaonZero");
00089   AntiKaonZero.setDefinition("AntiKaonZero");
00090   KaonMinus.setDefinition("KaonMinus"); 
00091   KaonZeroShort.setDefinition("KaonZeroShort");
00092   KaonZeroLong.setDefinition("KaonZeroLong"); 
00093   Proton.setDefinition("Proton");
00094   AntiProton.setDefinition("AntiProton");
00095   Neutron.setDefinition("Neutron");
00096   AntiNeutron.setDefinition("AntiNeutron");
00097   Lambda.setDefinition("Lambda");
00098   AntiLambda.setDefinition("AntiLambda");
00099   SigmaPlus.setDefinition("SigmaPlus"); 
00100   SigmaZero.setDefinition("SigmaZero");
00101   SigmaMinus.setDefinition("SigmaMinus");
00102   AntiSigmaPlus.setDefinition("AntiSigmaPlus");
00103   AntiSigmaZero.setDefinition("AntiSigmaZero");
00104   AntiSigmaMinus.setDefinition("AntiSigmaMinus");
00105   XiZero.setDefinition("XiZero");
00106   XiMinus.setDefinition("XiMinus"); 
00107   AntiXiZero.setDefinition("AntiXiZero");
00108   AntiXiMinus.setDefinition("AntiXiMinus");
00109   OmegaMinus.setDefinition("OmegaMinus");
00110   AntiOmegaMinus.setDefinition("AntiOmegaMinus");
00111   Deuteron.setDefinition("Deuteron"); 
00112   Triton.setDefinition("Triton"); 
00113   Alpha.setDefinition("Alpha");
00114   Gamma.setDefinition("Gamma");
00115   return;
00116 }

void G4HEInelastic::SetVerboseLevel ( const G4int  level  )  [inline]

Reimplemented from G4HadronicInteraction.

Reimplemented in G4HEAntiSigmaZeroInelastic, and G4HESigmaZeroInelastic.

Definition at line 76 of file G4HEInelastic.hh.

References verboseLevel.

Referenced by G4HESigmaZeroInelastic::ApplyYourself(), and G4HEAntiSigmaZeroInelastic::ApplyYourself().

00076 {verboseLevel = level;}

void G4HEInelastic::StrangeParticlePairProduction ( const G4double  availableEnergy,
const G4double  centerOfMassEnergy,
G4HEVector  pv[],
G4int vecLen,
const G4HEVector incidentParticle,
const G4HEVector targetParticle 
)

Definition at line 329 of file G4HEInelastic.cc.

References AntiLambda, AntiNeutron, AntiProton, AntiSigmaMinus, AntiSigmaPlus, AntiSigmaZero, G4cout, G4endl, G4UniformRand, G4HEVector::getCode(), G4HEVector::getMass(), KaonMinus, KaonPlus, KaonZeroLong, KaonZeroShort, Lambda, Neutron, Proton, SigmaMinus, SigmaPlus, SigmaZero, and verboseLevel.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), and G4HEAntiKaonZeroInelastic::ApplyYourself().

00342                                                :1 (from experimental low 
00343    // energy data)
00344 
00345  {
00346    static G4double avrs[]  = {3.,4.,5.,6.,7.,8.,9.,10.,20.,30.,40.,50.};
00347    static G4double avkkb[] = {0.0015,0.0050,0.0120,0.0285,0.0525,0.0750,0.0975,
00348                               0.1230,0.2800,0.3980,0.4950,0.5730};
00349    static G4double kkb[]   = {0.2500,0.3750,0.5000,0.5625,0.6250,0.6875,0.7500,
00350                               0.8750,1.0000};
00351    static G4double ky[]    = {0.2000,0.3000,0.4000,0.5500,0.6250,0.7000,0.8000,
00352                               0.8500,0.9000,0.9500,0.9750,1.0000};
00353    static G4int ipakkb[]   = {10,13,10,11,10,12,11,11,11,12,12,11,12,12,
00354                               11,13,12,13};
00355    static G4int ipaky[]    = {18,10,18,11,18,12,20,10,20,11,20,12,21,10,
00356                               21,11,21,12,22,10,22,11,22,12};
00357    static G4int ipakyb[]   = {19,13,19,12,19,11,23,13,23,12,23,11,24,13,
00358                               24,12,24,11,25,13,25,12,25,11};
00359    static G4double avky[]  = {0.0050,0.0300,0.0640,0.0950,0.1150,0.1300,0.1450,
00360                               0.1550,0.2000,0.2050,0.2100,0.2120};
00361    static G4double avnnb[] ={0.00001,0.0001,0.0006,0.0025,0.0100,0.0200,0.0400,
00362                               0.0500,0.1200,0.1500,0.1800,0.2000};
00363 
00364    G4int i, ibin, i3, i4;       // misc. local variables
00365    G4double avk, avy, avn, ran;
00366 
00367    G4double protonMass = Proton.getMass();
00368    G4double sigmaMinusMass = SigmaMinus.getMass();
00369    G4int antiprotonCode = AntiProton.getCode();
00370    G4int antineutronCode = AntiNeutron.getCode();
00371    G4int antilambdaCode = AntiLambda.getCode();    
00372 
00373    G4double incidentMass = incidentParticle.getMass();
00374    G4int incidentCode = incidentParticle.getCode();
00375 
00376    G4double targetMass = targetParticle.getMass();
00377 
00378      // protection against annihilation processes like pbar p -> pi pi.
00379 
00380    if (vecLen <= 2) return;   
00381 
00382      // determine the center of mass energy bin
00383 
00384    i = 1;
00385    while ( (i<12) && (centerOfMassEnergy > avrs[i]) )i++;
00386    if    ( i == 12 ) ibin = 11;
00387    else              ibin = i;
00388 
00389      // the fortran code chooses a random replacement of produced kaons
00390      // but does not take into account charge conservation 
00391 
00392    if( vecLen == 3 ) {               // we know that vecLen > 2
00393      i3 = 2;
00394      i4 = 3;                         // note that we will be adding a new 
00395    }                                 // secondary particle in this case only
00396    else 
00397    {                                 // otherwise  2 <= i3,i4 <= vecLen
00398      i4 = i3 = 2 + G4int( (vecLen-2)*G4UniformRand() );
00399      while ( i3 == i4 ) i4 = 2 + G4int( (vecLen-2)*G4UniformRand() );
00400    }
00401 
00402      // use linear interpolation or extrapolation by y=centerofmassEnergy*x+b
00403 
00404    avk = (std::log(avkkb[ibin])-std::log(avkkb[ibin-1]))*(centerOfMassEnergy-avrs[ibin-1])
00405           /(avrs[ibin]-avrs[ibin-1]) + std::log(avkkb[ibin-1]);
00406    avk = std::exp(avk);
00407 
00408    avy = (std::log(avky[ibin])-std::log(avky[ibin-1]))*(centerOfMassEnergy-avrs[ibin-1])
00409           /(avrs[ibin]-avrs[ibin-1]) + std::log(avky[ibin-1]);
00410    avy = std::exp(avy);
00411 
00412    avn = (std::log(avnnb[ibin])-std::log(avnnb[ibin-1]))*(centerOfMassEnergy-avrs[ibin-1])
00413           /(avrs[ibin]-avrs[ibin-1]) + std::log(avnnb[ibin-1]);
00414    avn = std::exp(avn);
00415 
00416    if ( avk+avy+avn <= 0.0 ) return;
00417 
00418    if ( incidentMass < protonMass ) avy /= 2.0;
00419    avy += avk+avn;
00420    avk += avn;
00421 
00422    ran = G4UniformRand();
00423    if (  ran < avn ) 
00424       {                                         // p pbar && n nbar production
00425          if ( availableEnergy < 2.0) return;
00426          if ( vecLen == 3 )                 
00427             {                                   // add a new secondary
00428               if ( G4UniformRand() < 0.5 ) 
00429                 {
00430                   pv[i3] = Neutron;;
00431                   pv[vecLen++] = AntiNeutron;
00432                 } 
00433               else 
00434                 {
00435                   pv[i3] = Proton;
00436                   pv[vecLen++] = AntiProton;
00437                 }
00438             } 
00439          else 
00440             {                                   // replace two secondaries
00441               if ( G4UniformRand() < 0.5 ) 
00442                 {
00443                   pv[i3] = Neutron;
00444                   pv[i4] = AntiNeutron;
00445                 } 
00446               else 
00447                 {
00448                   pv[i3] = Proton;
00449                   pv[i4] = AntiProton;
00450                 }
00451             }
00452       } 
00453    else if ( ran < avk ) 
00454       {                                         // K Kbar production
00455         if ( availableEnergy < 1.0) return;
00456         G4double ran1 = G4UniformRand();
00457         i = 0;
00458         while( (i<9) && (ran1>kkb[i]) )i++;
00459         if ( i == 9 ) return;
00460 
00461                // ipakkb[] = { 10,13, 10,11, 10,12, 11, 11,  11,12, 12,11, 12,12, 11,13, 12,13 };
00462                // charge       K+ K-  K+ K0S K+ K0L K0S K0S K0S K0L K0LK0S K0LK0L K0S K- K0LK-
00463 
00464         switch( ipakkb[i*2] ) 
00465           {
00466             case 10: pv[i3] = KaonPlus;     break;
00467             case 11: pv[i3] = KaonZeroShort;break;
00468             case 12: pv[i3] = KaonZeroLong; break;
00469             case 13: pv[i3] = KaonMinus;    break;
00470           }
00471 
00472         if( vecLen == 2 ) 
00473           {                                                // add a secondary
00474             switch( ipakkb[i*2+1] ) 
00475               {
00476                 case 10: pv[vecLen++] = KaonPlus;     break;
00477                 case 11: pv[vecLen++] = KaonZeroShort;break;
00478                 case 12: pv[vecLen++] = KaonZeroLong; break;
00479                 case 13: pv[vecLen++] = KaonMinus;    break;
00480               }
00481           } 
00482         else 
00483           {                                        // replace
00484             switch( ipakkb[i*2+1] ) 
00485               {
00486                 case 10: pv[i4] = KaonPlus;     break;
00487                 case 11: pv[i4] = KaonZeroShort;break;
00488                 case 12: pv[i4] = KaonZeroLong; break;
00489                 case 13: pv[i4] = KaonMinus;    break;
00490               }
00491           }
00492       } 
00493    else if ( ran < avy ) 
00494       {                                            // Lambda K && Sigma K
00495         if( availableEnergy < 1.6) return;
00496         G4double ran1 = G4UniformRand();
00497         i = 0;
00498         while( (i<12) && (ran1>ky[i]) )i++;
00499         if ( i == 12 ) return;
00500         if ( (incidentMass<protonMass) || (G4UniformRand()<0.5) ) 
00501            {
00502 
00503                     // ipaky[] = { 18,10, 18,11, 18,12, 20,10, 20,11, 20,12,
00504                     //             L0 K+  L0 K0S L0 K0L S+ K+  S+ K0S S+ K0L 
00505                     //
00506                     //             21,10, 21,11, 21,12, 22,10, 22,11, 22,12 }
00507                     //             S0 K+  S0 K0S S0 K0L S- K+  S- K0S S- K0L
00508 
00509               switch( ipaky[i*2] ) 
00510                  {
00511                    case 18: pv[1] = Lambda;    break;
00512                    case 20: pv[1] = SigmaPlus; break;
00513                    case 21: pv[1] = SigmaZero; break;
00514                    case 22: pv[1] = SigmaMinus;break;
00515                  }
00516               switch( ipaky[i*2+1] ) 
00517                  {
00518                    case 10: pv[i3] = KaonPlus;     break;
00519                    case 11: pv[i3] = KaonZeroShort;break;
00520                    case 12: pv[i3] = KaonZeroLong; break;
00521                  }
00522            } 
00523         else 
00524            {                               // Lbar K && Sigmabar K production 
00525 
00526                   // ipakyb[] = { 19,13, 19,12, 19,11,  23,13,  23,12,  23,11,
00527                   //              Lb K-  Lb K0L Lb K0S  S+b K- S+b K0L S+b K0S 
00528                   //              24,13, 24,12, 24,11, 25,13, 25,12, 25,11 };
00529                   //             S0b K-  S0BK0L S0BK0S S-BK- S-B K0L S-BK0S    
00530       
00531               if( (incidentCode==antiprotonCode) || (incidentCode==antineutronCode) ||
00532                   (incidentCode==antilambdaCode) || (incidentMass>sigmaMinusMass) ) 
00533                 {
00534                   switch( ipakyb[i*2] ) 
00535                    {
00536                     case 19:pv[0] = AntiLambda;    break;
00537                     case 23:pv[0] = AntiSigmaPlus; break;
00538                     case 24:pv[0] = AntiSigmaZero; break;
00539                     case 25:pv[0] = AntiSigmaMinus;break;
00540                    }
00541                   switch( ipakyb[i*2+1] ) 
00542                    {
00543                     case 11:pv[i3] = KaonZeroShort;break;
00544                     case 12:pv[i3] = KaonZeroLong; break;
00545                     case 13:pv[i3] = KaonMinus;    break;
00546                    }
00547                 } 
00548               else 
00549                 {
00550                   switch( ipaky[i*2] ) 
00551                    {
00552                     case 18:pv[0] = Lambda;    break;
00553                     case 20:pv[0] = SigmaPlus; break;
00554                     case 21:pv[0] = SigmaZero; break;
00555                     case 22:pv[0] = SigmaMinus;break;
00556                    }
00557                   switch( ipaky[i*2+1] ) 
00558                    {
00559                     case 10: pv[i3] = KaonPlus;     break;
00560                     case 11: pv[i3] = KaonZeroShort;break;
00561                     case 12: pv[i3] = KaonZeroLong; break;
00562                    }
00563                 }
00564            }
00565       } 
00566    else 
00567       return;
00568 
00569          //  check the available energy
00570          //   if there is not enough energy for kkb/ky pair production
00571          //   then reduce the number of secondary particles 
00572          //  NOTE:
00573          //        the number of secondaries may have been changed
00574          //        the incident and/or target particles may have changed
00575          //        charge conservation is ignored (as well as strangness conservation)
00576 
00577    incidentMass = incidentParticle.getMass();
00578    targetMass   = targetParticle.getMass();
00579 
00580    G4double energyCheck = centerOfMassEnergy-(incidentMass+targetMass);
00581    if (verboseLevel > 1) G4cout << "Particles produced: " ;
00582   
00583    for ( i=0; i < vecLen; i++ ) 
00584        {
00585          energyCheck -= pv[i].getMass(); 
00586          if (verboseLevel > 1) G4cout << pv[i].getCode() << " " ;
00587          if( energyCheck < 0.0 ) 
00588            {
00589              if( i > 0 ) vecLen = --i;      // chop off the secondary list
00590              return;
00591            }
00592        }
00593    if (verboseLevel > 1) G4cout << G4endl;
00594    return;
00595  }

void G4HEInelastic::TuningOfHighEnergyCascading ( G4HEVector  pv[],
G4int vecLen,
const G4HEVector incidentParticle,
const G4HEVector targetParticle,
G4double  atomicWeight,
G4double  atomicNumber 
)

Definition at line 1755 of file G4HEInelastic.cc.

References G4HEVector::Add(), G4HEVector::Add3(), Amax(), conserveEnergy, G4HEVector::CosAng(), G4HEVector::Cross(), G4cout, G4endl, G4UniformRand, G4HEVector::getBaryonNumber(), G4HEVector::getCharge(), G4HEVector::getCode(), G4HEVector::getKineticEnergy(), G4HEVector::getMass(), G4HEVector::getMomentum(), G4HEVector::getName(), G4HEVector::getStrangenessNumber(), G4HEVector::getTotalMomentum(), G4HEVector::Length(), G4HEVector::Lor(), Neutron, neutronCode, PionMinus, PionPlus, PionZero, G4HEVector::Print(), Proton, G4HEVector::setEnergy(), G4HEVector::setKineticEnergyAndUpdate(), G4HEVector::setMomentumAndUpdate(), G4HEVector::setZero(), G4HEVector::Smul(), G4HEVector::SmulAndUpdate(), sqr(), G4HEVector::Sub3(), and verboseLevel.

Referenced by HighEnergyCascading(), and HighEnergyClusterProduction().

01761 {
01762   G4int i,j;
01763   G4double incidentKineticEnergy   = incidentParticle.getKineticEnergy();
01764   G4double incidentTotalMomentum   = incidentParticle.getTotalMomentum();
01765   G4double incidentCharge          = incidentParticle.getCharge(); 
01766   G4double incidentMass            = incidentParticle.getMass();
01767   G4double targetMass              = targetParticle.getMass();
01768   G4int    pionPlusCode            = PionPlus.getCode();
01769   G4int    pionMinusCode           = PionMinus.getCode();
01770   G4int    pionZeroCode            = PionZero.getCode();  
01771   G4int    protonCode              = Proton.getCode();
01772   G4int    neutronCode             = Neutron.getCode();
01773   G4HEVector *pvmx   = new G4HEVector [10];
01774   G4double   *reddec = new G4double [7];
01775 
01776   if (incidentKineticEnergy > (25.+G4UniformRand()*75.) ) {
01777     G4double reden = -0.7 + 0.29*std::log10(incidentKineticEnergy);
01778 //       G4double redat =  1.0 - 0.40*std::log10(atomicWeight);
01779 //       G4double redat = 0.5 - 0.18*std::log10(atomicWeight);
01780     G4double redat = 0.722 - 0.278*std::log10(atomicWeight);
01781     G4double pmax   = -200.;
01782     G4double pmapim = -200.;
01783     G4double pmapi0 = -200.;
01784     G4double pmapip = -200.;
01785     G4int ipmax  = 0;
01786     G4int maxpim = 0;
01787     G4int maxpi0 = 0;
01788     G4int maxpip = 0;
01789     G4int iphmf; 
01790        if (   (G4UniformRand() > (atomicWeight/100.-0.28)) 
01791            && (std::fabs(incidentCharge) > 0.) )
01792          { 
01793            for (i=0; i < vecLen; i++)
01794              { 
01795                iphmf = pv[i].getCode();
01796                G4double ppp = pv[i].Length();
01797                if ( ppp > pmax) 
01798                  { 
01799                    pmax  = ppp; ipmax = i;
01800                  }
01801                if (iphmf == pionPlusCode && ppp > pmapip ) 
01802                  { 
01803                    pmapip = ppp; maxpip = i;       
01804                  }   
01805                else if (iphmf == pionZeroCode && ppp > pmapi0)
01806                  { 
01807                    pmapi0 = ppp; maxpi0 = i;
01808                  }
01809                else if (iphmf == pionMinusCode && ppp > pmapim)
01810                  { 
01811                    pmapim = ppp; maxpim = i;  
01812                  }                       
01813              }
01814          }
01815        if(verboseLevel > 1)
01816          {
01817            G4cout << "ipmax, pmax   " << ipmax  << " " << pmax   << G4endl;
01818            G4cout << "maxpip,pmapip " << maxpip << " " << pmapip << G4endl;
01819            G4cout << "maxpi0,pmapi0 " << maxpi0 << " " << pmapi0 << G4endl;
01820            G4cout << "maxpim,pmapim " << maxpim << " " << pmapim << G4endl; 
01821          }
01822 
01823        if ( vecLen > 2)
01824          { 
01825            for (i=2; i<vecLen; i++)
01826              { 
01827                iphmf = pv[i].getCode();
01828                if (    ((iphmf==protonCode)||(iphmf==neutronCode)||(pv[i].getType()=="Nucleus"))   
01829                     && (pv[i].Length()<1.5)
01830                     && ((G4UniformRand()<reden)||(G4UniformRand()<redat)))
01831                   {
01832                     pv[i].setMomentumAndUpdate( 0., 0., 0.);
01833                     if(verboseLevel > 1)
01834                       {
01835                         G4cout << "zero Momentum for particle " << G4endl;
01836                         pv[i].Print(i);
01837                       }                                  
01838                   } 
01839              }  
01840          }
01841        if (maxpi0 == ipmax)
01842          { 
01843            if (G4UniformRand() < pmapi0/incidentTotalMomentum) 
01844             { 
01845               if ((incidentCharge > 0.5) && (maxpip != 0))
01846                 { 
01847                   G4ParticleMomentum mompi0 = pv[maxpi0].getMomentum();
01848                   pv[maxpi0].setMomentumAndUpdate( pv[maxpip].getMomentum() );
01849                   pv[maxpip].setMomentumAndUpdate( mompi0);
01850                   if(verboseLevel > 1)
01851                     {
01852                       G4cout << " exchange Momentum for " << maxpi0 << " and " << maxpip << G4endl;
01853                     } 
01854                 }
01855               else if ((incidentCharge < -0.5) && (maxpim != 0))
01856                 { 
01857                   G4ParticleMomentum mompi0 = pv[maxpi0].getMomentum();
01858                   pv[maxpi0].setMomentumAndUpdate( pv[maxpim].getMomentum() );
01859                   pv[maxpim].setMomentumAndUpdate( mompi0);
01860                   if(verboseLevel > 1)
01861                     {
01862                       G4cout << " exchange Momentum for " << maxpi0 << " and " << maxpip << G4endl;
01863                     }   
01864                 }
01865             }
01866          }
01867        G4double bntot = - incidentParticle.getBaryonNumber() - atomicWeight;
01868        for (i=0; i<vecLen; i++) bntot += pv[i].getBaryonNumber();
01869        if(atomicWeight < 1.5) { bntot = 0.; }
01870        else                   { bntot = 1. + bntot/atomicWeight; }
01871        if(atomicWeight > (75.+G4UniformRand()*50.)) bntot = 0.;
01872        if(verboseLevel > 1) 
01873          {
01874            G4cout << " Calculated Baryon- Number " << bntot << G4endl;
01875          }
01876 
01877        j = 0;
01878        for (i=0; i<vecLen; i++)
01879          { 
01880            G4double ppp = pv[i].Length();
01881            if ( ppp > 1.e-6)
01882              { 
01883                iphmf = pv[i].getCode();
01884                if(    (bntot > 0.3) 
01885                    && ((iphmf == protonCode) || (iphmf == neutronCode) 
01886                                              || (pv[i].getType() == "Nucleus") )
01887                    && (G4UniformRand() < 0.25) 
01888                    && (ppp < 1.2)  ) 
01889                  { 
01890                    if(verboseLevel > 1)
01891                      {
01892                        G4cout << " skip Baryon: " << G4endl;
01893                        pv[i].Print(i);
01894                      }
01895                    continue; 
01896 
01897                  }   
01898                if (j != i)
01899                  { 
01900                    pv[j] = pv[i];
01901                  }
01902                j++;
01903              }
01904          }
01905        vecLen = j;     
01906   }
01907 
01908   pvmx[0] = incidentParticle;
01909   pvmx[1] = targetParticle;
01910   pvmx[8].setZero();
01911   pvmx[2].Add(pvmx[0], pvmx[1]);
01912   pvmx[3].Lor(pvmx[0], pvmx[2]);
01913   pvmx[4].Lor(pvmx[1], pvmx[2]);
01914    
01915   if (verboseLevel > 1) {
01916     pvmx[0].Print(0);
01917     incidentParticle.Print(0);
01918     pvmx[1].Print(1);
01919     targetParticle.Print(1);
01920     pvmx[2].Print(2);
01921     pvmx[3].Print(3);
01922     pvmx[4].Print(4);
01923   }
01924 
01925   // Calculate leading particle effect in which a single final state 
01926   // particle carries away nearly the maximum allowed momentum, while
01927   // all other secondaries have reduced momentum.  A secondary is 
01928   // proportionately less likely to be a leading particle as the 
01929   // difference of its quantum numbers with the primary increases.
01930  
01931   G4int ledpar = -1;
01932   G4double redpar = 0.;
01933   G4int incidentS = incidentParticle.getStrangenessNumber();
01934   if (incidentParticle.getName() == "KaonZeroShort" || 
01935       incidentParticle.getName() == "KaonZeroLong") {
01936     if(G4UniformRand() < 0.5) { 
01937       incidentS = 1;
01938     } else { 
01939       incidentS = -1;
01940     }
01941   }
01942 
01943   G4int incidentB =   incidentParticle.getBaryonNumber();   
01944 
01945   for (i=0; i<vecLen; i++) { 
01946     G4int iphmf = pv[i].getCode();
01947     G4double ppp = pv[i].Length();
01948 
01949     if (ppp > 1.e-3) { 
01950       pvmx[5].Lor( pv[i], pvmx[2] );  // secondary in CM frame
01951       G4double cost = pvmx[3].CosAng( pvmx[5] );
01952 
01953       // For each secondary, find the sum of the differences of its 
01954       // quantum numbers with that of the incident particle 
01955       // (dM + dQ + dS + dB)
01956 
01957       G4int particleS = pv[i].getStrangenessNumber();
01958 
01959       if (pv[i].getName() == "KaonZeroShort" || 
01960           pv[i].getName() == "KaonZeroLong") {
01961         if (G4UniformRand() < 0.5) { 
01962           particleS = 1;
01963         } else { 
01964           particleS = -1;
01965         }
01966       } 
01967       G4int particleB = pv[i].getBaryonNumber();
01968       G4double hfmass;
01969       if (cost > 0.) { 
01970         reddec[0] = std::fabs( incidentMass - pv[i].getMass() );
01971         reddec[1] = std::fabs( incidentCharge - pv[i].getCharge());
01972         reddec[2] = std::fabs( G4double(incidentS - particleS) ); // cast for aCC
01973         reddec[3] = std::fabs( G4double(incidentB - particleB) ); // cast for aCC
01974         hfmass = incidentMass;
01975 
01976       } else { 
01977         reddec[0] = std::fabs( targetMass - pv[i].getMass() );
01978         reddec[1] = std::fabs( atomicNumber/atomicWeight - pv[i].getCharge());
01979         reddec[2] = std::fabs( G4double(particleS) ); // cast for aCC
01980         reddec[3] = std::fabs( 1. - particleB );
01981         hfmass = targetMass;  
01982       }
01983 
01984       reddec[5] = reddec[0]+reddec[1]+reddec[2]+reddec[3];
01985       G4double sbqwgt = reddec[5];
01986       if (hfmass < 0.2) { 
01987         sbqwgt = (sbqwgt-2.5)*0.10;
01988         if(pv[i].getCode() == pionZeroCode) sbqwgt = 0.15; 
01989       } else if (hfmass < 0.6) {
01990         sbqwgt = (sbqwgt-3.0)*0.10;
01991       } else { 
01992         sbqwgt = (sbqwgt-2.0)*0.10;
01993         if(pv[i].getCode() == pionZeroCode) sbqwgt = 0.15;
01994       }
01995            
01996       ppp = pvmx[5].Length();
01997 
01998       // Reduce the longitudinal momentum of the secondary by a factor 
01999       // which is a function of the sum of the differences
02000 
02001       if (sbqwgt > 0. && ppp > 1.e-6) { 
02002         G4double pthmf = ppp*std::sqrt(1.-cost*cost);
02003         G4double plhmf = ppp*cost*(1.-sbqwgt);
02004         pvmx[7].Cross( pvmx[3], pvmx[5] );
02005         pvmx[7].Cross( pvmx[7], pvmx[3] );
02006 
02007         if (pvmx[3].Length() > 0.)
02008           pvmx[6].SmulAndUpdate( pvmx[3], plhmf/pvmx[3].Length() );
02009         else if(verboseLevel > 1)
02010           G4cout << "NaNQ in Tuning of High Energy Hadronic Interactions" << G4endl;
02011 
02012         if (pvmx[7].Length() > 0.)    
02013           pvmx[7].SmulAndUpdate( pvmx[7], pthmf/pvmx[7].Length() );
02014         else if(verboseLevel > 1)
02015           G4cout << "NaNQ in Tuning of High Energy Hadronic Interactions" << G4endl;
02016 
02017         pvmx[5].Add3(pvmx[6], pvmx[7] );
02018         pvmx[5].setEnergy( std::sqrt(sqr(pvmx[5].Length()) + sqr(pv[i].getMass())));
02019         pv[i].Lor( pvmx[5], pvmx[4] );
02020         if (verboseLevel > 1) {
02021           G4cout << " Particle Momentum changed to: " << G4endl;
02022           pv[i].Print(i); 
02023         }
02024       }
02025 
02026       // Choose leading particle
02027       // Neither pi0s, backward nucleons from intra-nuclear cascade,
02028       // nor evaporation fragments can be leading particles
02029 
02030       G4int ss = -3;
02031       if (incidentS != 0) ss = 0;
02032       if (iphmf != pionZeroCode && pv[i].getSide() > ss) { 
02033         pvmx[7].Sub3( incidentParticle, pv[i] );
02034         reddec[4] = pvmx[7].Length()/incidentTotalMomentum;
02035         reddec[6] = reddec[4]*2./3. + reddec[5]/12.;
02036         reddec[6] = Amax(0., 1. - reddec[6]);
02037         if ( (reddec[5] <= 3.75) && (reddec[6] > redpar) ) { 
02038           ledpar = i;
02039           redpar = reddec[6]; 
02040         }   
02041       } 
02042     }
02043     pvmx[8].Add3(pvmx[8], pv[i] );
02044   }
02045 
02046   if(false) if (ledpar >= 0)
02047      { 
02048        if(verboseLevel > 1)
02049        {
02050           G4cout << " Leading Particle found : " << ledpar << G4endl;
02051           pv[ledpar].Print(ledpar);
02052           pvmx[8].Print(-2);
02053           incidentParticle.Print(-1);
02054        }
02055        pvmx[4].Sub3(incidentParticle,pvmx[8]);
02056        pvmx[5].Smul(incidentParticle, incidentParticle.CosAng(pvmx[4])
02057                                      *pvmx[4].Length()/incidentParticle.Length());
02058        pv[ledpar].Add3(pv[ledpar],pvmx[5]);
02059 
02060        pv[ledpar].SmulAndUpdate( pv[ledpar], 1.);
02061        if(verboseLevel > 1)
02062        {
02063            pv[ledpar].Print(ledpar);
02064        }  
02065      }
02066 
02067   if (conserveEnergy) {
02068     G4double ekinhf = 0.;
02069     for (i=0; i<vecLen; i++) {
02070       ekinhf += pv[i].getKineticEnergy();
02071       if(pv[i].getMass() < 0.7) ekinhf += pv[i].getMass();
02072     }
02073     if(incidentParticle.getMass() < 0.7) ekinhf -= incidentParticle.getMass();
02074 
02075     if(ledpar < 0) {   // no leading particle chosen
02076       ekinhf = incidentParticle.getKineticEnergy()/ekinhf;
02077       for (i=0; i<vecLen; i++) 
02078         pv[i].setKineticEnergyAndUpdate(ekinhf*pv[i].getKineticEnergy());
02079 
02080     } else {   
02081       // take the energy removed from non-leading particles and
02082       // give it to the leading particle
02083       ekinhf = incidentParticle.getKineticEnergy() - ekinhf;
02084       ekinhf += pv[ledpar].getKineticEnergy();
02085       if(ekinhf < 0.) ekinhf = 0.;
02086       pv[ledpar].setKineticEnergyAndUpdate(ekinhf);
02087     }
02088   }
02089 
02090   delete [] reddec;
02091   delete [] pvmx;
02092 
02093   return;
02094  }     


Field Documentation

G4HEVector G4HEInelastic::Alpha

Definition at line 244 of file G4HEInelastic.hh.

Referenced by HighEnergyCascading(), and SetParticles().

G4HEVector G4HEInelastic::AntiKaonZero

Definition at line 220 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), HighEnergyCascading(), MediumEnergyCascading(), and SetParticles().

G4HEVector G4HEInelastic::AntiLambda

Definition at line 229 of file G4HEInelastic.hh.

Referenced by G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiNeutron

Definition at line 227 of file G4HEInelastic.hh.

Referenced by G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiOmegaMinus

Definition at line 241 of file G4HEInelastic.hh.

Referenced by SetParticles().

G4HEVector G4HEInelastic::AntiProton

Definition at line 225 of file G4HEInelastic.hh.

Referenced by G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), QuasiElasticScattering(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiSigmaMinus

Definition at line 235 of file G4HEInelastic.hh.

Referenced by G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiSigmaPlus

Definition at line 233 of file G4HEInelastic.hh.

Referenced by G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiSigmaZero

Definition at line 234 of file G4HEInelastic.hh.

Referenced by G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::AntiXiMinus

Definition at line 239 of file G4HEInelastic.hh.

Referenced by SetParticles().

G4HEVector G4HEInelastic::AntiXiZero

Definition at line 238 of file G4HEInelastic.hh.

Referenced by SetParticles().

G4bool G4HEInelastic::conserveEnergy

Definition at line 80 of file G4HEInelastic.hh.

Referenced by EnergyConservation(), ForceEnergyConservation(), G4HEInelastic(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::Deuteron

Definition at line 242 of file G4HEInelastic.hh.

Referenced by HighEnergyCascading(), and SetParticles().

G4HEVector G4HEInelastic::Gamma

Definition at line 245 of file G4HEInelastic.hh.

Referenced by G4HESigmaZeroInelastic::ApplyYourself(), G4HEAntiSigmaZeroInelastic::ApplyYourself(), and SetParticles().

G4HEVector G4HEInelastic::KaonMinus

Definition at line 221 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), HighEnergyCascading(), MediumEnergyCascading(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::KaonPlus

Definition at line 218 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::KaonZero

Definition at line 219 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), HighEnergyCascading(), MediumEnergyCascading(), and SetParticles().

G4HEVector G4HEInelastic::KaonZeroLong

Definition at line 223 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), HighEnergyCascading(), MediumEnergyCascading(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::KaonZeroShort

Definition at line 222 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), HighEnergyCascading(), MediumEnergyCascading(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::Lambda

Definition at line 228 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), SetParticles(), and StrangeParticlePairProduction().

G4int G4HEInelastic::MAXPART

Reimplemented in G4HEAntiSigmaZeroInelastic, and G4HESigmaZeroInelastic.

Definition at line 79 of file G4HEInelastic.hh.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), G4HEAntiKaonZeroInelastic::ApplyYourself(), G4HEAntiKaonZeroInelastic::G4HEAntiKaonZeroInelastic(), G4HEAntiLambdaInelastic::G4HEAntiLambdaInelastic(), G4HEAntiNeutronInelastic::G4HEAntiNeutronInelastic(), G4HEAntiOmegaMinusInelastic::G4HEAntiOmegaMinusInelastic(), G4HEAntiProtonInelastic::G4HEAntiProtonInelastic(), G4HEAntiSigmaMinusInelastic::G4HEAntiSigmaMinusInelastic(), G4HEAntiSigmaPlusInelastic::G4HEAntiSigmaPlusInelastic(), G4HEAntiXiMinusInelastic::G4HEAntiXiMinusInelastic(), G4HEAntiXiZeroInelastic::G4HEAntiXiZeroInelastic(), G4HEInelastic(), G4HEKaonMinusInelastic::G4HEKaonMinusInelastic(), G4HEKaonPlusInelastic::G4HEKaonPlusInelastic(), G4HEKaonZeroInelastic::G4HEKaonZeroInelastic(), G4HEKaonZeroLongInelastic::G4HEKaonZeroLongInelastic(), G4HEKaonZeroShortInelastic::G4HEKaonZeroShortInelastic(), G4HELambdaInelastic::G4HELambdaInelastic(), G4HENeutronInelastic::G4HENeutronInelastic(), G4HEOmegaMinusInelastic::G4HEOmegaMinusInelastic(), G4HEPionMinusInelastic::G4HEPionMinusInelastic(), G4HEPionPlusInelastic::G4HEPionPlusInelastic(), G4HEProtonInelastic::G4HEProtonInelastic(), G4HESigmaMinusInelastic::G4HESigmaMinusInelastic(), G4HESigmaPlusInelastic::G4HESigmaPlusInelastic(), G4HEXiMinusInelastic::G4HEXiMinusInelastic(), G4HEXiZeroInelastic::G4HEXiZeroInelastic(), and SetMaxNumberOfSecondaries().

G4HEVector G4HEInelastic::Neutron

Definition at line 226 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), NuclearExcitation(), SetParticles(), StrangeParticlePairProduction(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::OmegaMinus

Definition at line 240 of file G4HEInelastic.hh.

Referenced by G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), and SetParticles().

G4HEVector G4HEInelastic::PionMinus

Definition at line 217 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), SetParticles(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::PionPlus

Definition at line 215 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), QuasiElasticScattering(), SetParticles(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::PionZero

Definition at line 216 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), SetParticles(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::Proton

Definition at line 224 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), QuasiElasticScattering(), SetParticles(), StrangeParticlePairProduction(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::SigmaMinus

Definition at line 232 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::SigmaPlus

Definition at line 230 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::SigmaZero

Definition at line 231 of file G4HEInelastic.hh.

Referenced by G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), HighEnergyCascading(), SetParticles(), and StrangeParticlePairProduction().

G4HEVector G4HEInelastic::Triton

Definition at line 243 of file G4HEInelastic.hh.

Referenced by HighEnergyCascading(), and SetParticles().

G4int G4HEInelastic::verboseLevel

Reimplemented from G4HadronicInteraction.

Reimplemented in G4HEAntiSigmaZeroInelastic, and G4HESigmaZeroInelastic.

Definition at line 78 of file G4HEInelastic.hh.

Referenced by G4HEXiZeroInelastic::ApplyYourself(), G4HEXiMinusInelastic::ApplyYourself(), G4HESigmaPlusInelastic::ApplyYourself(), G4HESigmaMinusInelastic::ApplyYourself(), G4HEProtonInelastic::ApplyYourself(), G4HEPionPlusInelastic::ApplyYourself(), G4HEPionMinusInelastic::ApplyYourself(), G4HEOmegaMinusInelastic::ApplyYourself(), G4HENeutronInelastic::ApplyYourself(), G4HELambdaInelastic::ApplyYourself(), G4HEKaonZeroShortInelastic::ApplyYourself(), G4HEKaonZeroLongInelastic::ApplyYourself(), G4HEKaonZeroInelastic::ApplyYourself(), G4HEKaonPlusInelastic::ApplyYourself(), G4HEKaonMinusInelastic::ApplyYourself(), G4HEAntiXiZeroInelastic::ApplyYourself(), G4HEAntiXiMinusInelastic::ApplyYourself(), G4HEAntiSigmaPlusInelastic::ApplyYourself(), G4HEAntiSigmaMinusInelastic::ApplyYourself(), G4HEAntiProtonInelastic::ApplyYourself(), G4HEAntiOmegaMinusInelastic::ApplyYourself(), G4HEAntiNeutronInelastic::ApplyYourself(), G4HEAntiLambdaInelastic::ApplyYourself(), G4HEAntiKaonZeroInelastic::ApplyYourself(), ElasticScattering(), G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(), G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(), G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(), G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(), G4HEAntiProtonInelastic::FirstIntInCasAntiProton(), G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(), G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(), G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(), G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(), G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(), G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(), G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(), G4HEKaonZeroInelastic::FirstIntInCasKaonZero(), G4HELambdaInelastic::FirstIntInCasLambda(), G4HENeutronInelastic::FirstIntInCasNeutron(), G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEPionMinusInelastic::FirstIntInCasPionMinus(), G4HEPionPlusInelastic::FirstIntInCasPionPlus(), G4HEProtonInelastic::FirstIntInCasProton(), G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(), G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), G4HEAntiKaonZeroInelastic::G4HEAntiKaonZeroInelastic(), G4HEAntiLambdaInelastic::G4HEAntiLambdaInelastic(), G4HEAntiNeutronInelastic::G4HEAntiNeutronInelastic(), G4HEAntiOmegaMinusInelastic::G4HEAntiOmegaMinusInelastic(), G4HEAntiProtonInelastic::G4HEAntiProtonInelastic(), G4HEAntiSigmaMinusInelastic::G4HEAntiSigmaMinusInelastic(), G4HEAntiSigmaPlusInelastic::G4HEAntiSigmaPlusInelastic(), G4HEAntiXiMinusInelastic::G4HEAntiXiMinusInelastic(), G4HEAntiXiZeroInelastic::G4HEAntiXiZeroInelastic(), G4HEInelastic(), G4HEKaonMinusInelastic::G4HEKaonMinusInelastic(), G4HEKaonPlusInelastic::G4HEKaonPlusInelastic(), G4HEKaonZeroInelastic::G4HEKaonZeroInelastic(), G4HEKaonZeroLongInelastic::G4HEKaonZeroLongInelastic(), G4HEKaonZeroShortInelastic::G4HEKaonZeroShortInelastic(), G4HELambdaInelastic::G4HELambdaInelastic(), G4HENeutronInelastic::G4HENeutronInelastic(), G4HEOmegaMinusInelastic::G4HEOmegaMinusInelastic(), G4HEPionMinusInelastic::G4HEPionMinusInelastic(), G4HEPionPlusInelastic::G4HEPionPlusInelastic(), G4HEProtonInelastic::G4HEProtonInelastic(), G4HESigmaMinusInelastic::G4HESigmaMinusInelastic(), G4HESigmaPlusInelastic::G4HESigmaPlusInelastic(), G4HEXiMinusInelastic::G4HEXiMinusInelastic(), G4HEXiZeroInelastic::G4HEXiZeroInelastic(), HighEnergyCascading(), HighEnergyClusterProduction(), MediumEnergyCascading(), MediumEnergyClusterProduction(), NBodyPhaseSpace(), NuclearExcitation(), NuclearInelasticity(), QuasiElasticScattering(), SetVerboseLevel(), StrangeParticlePairProduction(), and TuningOfHighEnergyCascading().

G4HEVector G4HEInelastic::XiMinus

Definition at line 237 of file G4HEInelastic.hh.

Referenced by G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), and SetParticles().

G4HEVector G4HEInelastic::XiZero

Definition at line 236 of file G4HEInelastic.hh.

Referenced by G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(), G4HEXiMinusInelastic::FirstIntInCasXiMinus(), G4HEXiZeroInelastic::FirstIntInCasXiZero(), and SetParticles().


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