#include <G4RPGAntiXiZeroInelastic.hh>

Inheritance diagram for G4RPGAntiXiZeroInelastic:

Collaboration diagram for G4RPGAntiXiZeroInelastic:

Public Member Functions
	G4RPGAntiXiZeroInelastic ()

	~G4RPGAntiXiZeroInelastic ()

G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)

Public Member Functions inherited from G4RPGInelastic
	G4RPGInelastic (const G4String &modelName="RPGInelastic")

virtual	~G4RPGInelastic ()

Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")

virtual	~G4HadronicInteraction ()

virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)

virtual G4bool	IsApplicable (const G4HadProjectile &, G4Nucleus &)

G4double	GetMinEnergy () const

G4double	GetMinEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMinEnergy (G4double anEnergy)

void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)

G4double	GetMaxEnergy () const

G4double	GetMaxEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMaxEnergy (const G4double anEnergy)

void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)

const G4HadronicInteraction *	GetMyPointer () const

virtual G4int	GetVerboseLevel () const

virtual void	SetVerboseLevel (G4int value)

const G4String &	GetModelName () const

void	DeActivateFor (const G4Material *aMaterial)

void	ActivateFor (const G4Material *aMaterial)

void	DeActivateFor (const G4Element *anElement)

void	ActivateFor (const G4Element *anElement)

G4bool	IsBlocked (const G4Material *aMaterial) const

G4bool	IsBlocked (const G4Element *anElement) const

void	SetRecoilEnergyThreshold (G4double val)

G4double	GetRecoilEnergyThreshold () const

G4bool	operator== (const G4HadronicInteraction &right) const

G4bool	operator!= (const G4HadronicInteraction &right) const

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

virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

virtual void	ModelDescription (std::ostream &outFile) const

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

Private Member Functions
void	Cascade (G4FastVector< G4ReactionProduct, GHADLISTSIZE > &vec, G4int &vecLen, const G4HadProjectile *originalIncident, G4ReactionProduct &currentParticle, G4ReactionProduct &targetParticle, G4bool &incidentHasChanged, G4bool &targetHasChanged, G4bool &quasiElastic)

Additional Inherited Members
Protected Types inherited from G4RPGInelastic
enum	{ pi0, pip, pim, kp, km, k0, k0b, pro, neu, lam, sp, s0, sm, xi0, xim, om, ap, an }

Protected Member Functions inherited from G4RPGInelastic
G4double	Pmltpc (G4int np, G4int nm, G4int nz, G4int n, G4double b, G4double c)

G4int	Factorial (G4int n)

G4bool	MarkLeadingStrangeParticle (const G4ReactionProduct &currentParticle, const G4ReactionProduct &targetParticle, G4ReactionProduct &leadParticle)

void	SetUpPions (const G4int np, const G4int nm, const G4int nz, G4FastVector< G4ReactionProduct, 256 > &vec, G4int &vecLen)

void	GetNormalizationConstant (const G4double availableEnergy, G4double &n, G4double &anpn)

void	CalculateMomenta (G4FastVector< G4ReactionProduct, 256 > &vec, G4int &vecLen, const G4HadProjectile originalIncident, const G4DynamicParticle originalTarget, G4ReactionProduct &modifiedOriginal, G4Nucleus &targetNucleus, G4ReactionProduct &currentParticle, G4ReactionProduct &targetParticle, G4bool &incidentHasChanged, G4bool &targetHasChanged, G4bool quasiElastic)

void	SetUpChange (G4FastVector< G4ReactionProduct, 256 > &vec, G4int &vecLen, G4ReactionProduct &currentParticle, G4ReactionProduct &targetParticle, G4bool &incidentHasChanged)

std::pair< G4int, G4double >	interpolateEnergy (G4double ke) const

G4int	sampleFlat (std::vector< G4double > sigma) const

void	CheckQnums (G4FastVector< G4ReactionProduct, 256 > &vec, G4int &vecLen, G4ReactionProduct &currentParticle, G4ReactionProduct &targetParticle, G4double Q, G4double B, G4double S)

Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)

G4bool	IsBlocked () const

void	Block ()

Protected Attributes inherited from G4RPGInelastic
G4RPGFragmentation	fragmentation

G4RPGTwoCluster	twoCluster

G4RPGPionSuppression	pionSuppression

G4RPGStrangeProduction	strangeProduction

G4RPGTwoBody	twoBody

G4ParticleDefinition *	particleDef [18]

Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange

G4int	verboseLevel

G4double	theMinEnergy

G4double	theMaxEnergy

G4bool	isBlocked

Detailed Description

Definition at line 44 of file G4RPGAntiXiZeroInelastic.hh.

Constructor & Destructor Documentation

◆ G4RPGAntiXiZeroInelastic()

G4RPGAntiXiZeroInelastic::G4RPGAntiXiZeroInelastic ( )

inline

Definition at line 48 of file G4RPGAntiXiZeroInelastic.hh.

                                : G4RPGInelastic("G4RPGAntiXiZeroInelastic")
     {
       SetMinEnergy( 0.0 );
       SetMaxEnergy( 25.*CLHEP::GeV );
     }

Here is the call graph for this function:

◆ ~G4RPGAntiXiZeroInelastic()

G4RPGAntiXiZeroInelastic::~G4RPGAntiXiZeroInelastic ( )

inline

Definition at line 54 of file G4RPGAntiXiZeroInelastic.hh.

54 { }

Here is the call graph for this function:

Member Function Documentation

◆ ApplyYourself()

G4HadFinalState * G4RPGAntiXiZeroInelastic::ApplyYourself	(	const G4HadProjectile &	aTrack,
		G4Nucleus &	targetNucleus
	)

virtual

Implements G4HadronicInteraction.

Definition at line 40 of file G4RPGAntiXiZeroInelastic.cc.

 { 
   const G4HadProjectile *originalIncident = &aTrack;
 
   // Choose the target particle
 
   G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     
   if( verboseLevel > 1 )
   {
     const G4Material *targetMaterial = aTrack.GetMaterial();
     G4cout << "G4RPGAntiXiZeroInelastic::ApplyYourself called" << G4endl;
     G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
     G4cout << "target material = " << targetMaterial->GetName() << ", ";
     G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
            << G4endl;
   }
 
   // Fermi motion and evaporation
   // As of Geant3, the Fermi energy calculation had not been Done
 
     G4double ek = originalIncident->GetKineticEnergy()/MeV;
     G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
     G4ReactionProduct modifiedOriginal;
     modifiedOriginal = *originalIncident;
     
     G4double tkin = targetNucleus.Cinema( ek );
     ek += tkin;
     modifiedOriginal.SetKineticEnergy( ek*MeV );
     G4double et = ek + amas;
     G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
     G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
     if( pp > 0.0 )
     {
       G4ThreeVector momentum = modifiedOriginal.GetMomentum();
       modifiedOriginal.SetMomentum( momentum * (p/pp) );
     }
     //
     // calculate black track energies
     //
     tkin = targetNucleus.EvaporationEffects( ek );
     ek -= tkin;
     modifiedOriginal.SetKineticEnergy( ek*MeV );
     et = ek + amas;
     p = std::sqrt( std::abs((et-amas)*(et+amas)) );
     pp = modifiedOriginal.GetMomentum().mag()/MeV;
     if( pp > 0.0 )
     {
       G4ThreeVector momentum = modifiedOriginal.GetMomentum();
       modifiedOriginal.SetMomentum( momentum * (p/pp) );
     }
     G4ReactionProduct currentParticle = modifiedOriginal;
     G4ReactionProduct targetParticle;
     targetParticle = *originalTarget;
     currentParticle.SetSide( 1 ); // incident always goes in forward hemisphere
     targetParticle.SetSide( -1 );  // target always goes in backward hemisphere
     G4bool incidentHasChanged = false;
     G4bool targetHasChanged = false;
     G4bool quasiElastic = false;
     G4FastVector<G4ReactionProduct,GHADLISTSIZE> vec;  // vec will contain the secondary particles
     G4int vecLen = 0;
     vec.Initialize( 0 );
     
     const G4double cutOff = 0.1;
     const G4double anni = std::min( 1.3*currentParticle.GetTotalMomentum()/GeV, 0.4 );
     if( (currentParticle.GetKineticEnergy()/MeV > cutOff) || (G4UniformRand() > anni) )
       Cascade( vec, vecLen,
                originalIncident, currentParticle, targetParticle,
                incidentHasChanged, targetHasChanged, quasiElastic );
     
     CalculateMomenta( vec, vecLen,
                       originalIncident, originalTarget, modifiedOriginal,
                       targetNucleus, currentParticle, targetParticle,
                       incidentHasChanged, targetHasChanged, quasiElastic );
     
     SetUpChange( vec, vecLen,
                  currentParticle, targetParticle,
                  incidentHasChanged );
     
   delete originalTarget;
   return &theParticleChange;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cascade()

void G4RPGAntiXiZeroInelastic::Cascade	(	G4FastVector< G4ReactionProduct, GHADLISTSIZE > &	vec,
		G4int &	vecLen,
		const G4HadProjectile *	originalIncident,
		G4ReactionProduct &	currentParticle,
		G4ReactionProduct &	targetParticle,
		G4bool &	incidentHasChanged,
		G4bool &	targetHasChanged,
		G4bool &	quasiElastic
	)

private

Definition at line 125 of file G4RPGAntiXiZeroInelastic.cc.

 {
   // Derived from H. Fesefeldt's original FORTRAN code CASAX0
   // which is just a copy of CASX0 (cascade for Xi0)
   // AntiXiZero undergoes interaction with nucleon within a nucleus.  Check if it is
   // energetically possible to produce pions/kaons.  In not, assume nuclear excitation
   // occurs and input particle is degraded in energy. No other particles are produced.
   // If reaction is possible, find the correct number of pions/protons/neutrons
   // produced using an interpolation to multiplicity data.  Replace some pions or
   // protons/neutrons by kaons or strange baryons according to the average
   // multiplicity per inelastic reaction.
 
   const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
   const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
   const G4double targetMass = targetParticle.GetMass()/MeV;
   G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
                                       targetMass*targetMass +
                                       2.0*targetMass*etOriginal );
   G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
   if (availableEnergy <= G4PionPlus::PionPlus()->GetPDGMass()/MeV) {
     quasiElastic = true;
     return;
   }
   static G4ThreadLocal G4bool first = true;
   const G4int numMul = 1200;
   const G4int numSec = 60;
   static G4ThreadLocal G4double protmul[numMul], protnorm[numSec]; // proton constants
   static G4ThreadLocal G4double neutmul[numMul], neutnorm[numSec]; // neutron constants
 
   // np = number of pi+, nneg = number of pi-, nz = number of pi0
   G4int counter, nt=0, np=0, nneg=0, nz=0;
   G4double test;
   const G4double c = 1.25;    
   const G4double b[] = { 0.7, 0.7 };
   if (first) { // Computation of normalization constants will only be done once
     first = false;
     G4int i;
     for( i=0; i<numMul; ++i )protmul[i] = 0.0;
     for( i=0; i<numSec; ++i )protnorm[i] = 0.0;
     counter = -1;
     for (np = 0; np < (numSec/3); ++np) {
         for( nneg=std::max(0,np-2); nneg<=(np+1); ++nneg )
         {
           for( nz=0; nz<numSec/3; ++nz )
           {
             if( ++counter < numMul )
             {
               nt = np+nneg+nz;
               if( nt>0 && nt<=numSec )
               {
                 protmul[counter] = Pmltpc(np,nneg,nz,nt,b[0],c);
                 protnorm[nt-1] += protmul[counter];
               }
             }
           }
         }
       }
       for( i=0; i<numMul; ++i )neutmul[i] = 0.0;
       for( i=0; i<numSec; ++i )neutnorm[i] = 0.0;
       counter = -1;
       for( np=0; np<numSec/3; ++np )
       {
         for( nneg=std::max(0,np-1); nneg<=(np+2); ++nneg )
         {
           for( nz=0; nz<numSec/3; ++nz )
           {
             if( ++counter < numMul )
             {
               nt = np+nneg+nz;
               if( nt>0 && nt<=numSec )
               {
                 neutmul[counter] = Pmltpc(np,nneg,nz,nt,b[1],c);
                 neutnorm[nt-1] += neutmul[counter];
               }
             }
           }
         }
       }
       for( i=0; i<numSec; ++i )
       {
         if( protnorm[i] > 0.0 )protnorm[i] = 1.0/protnorm[i];
         if( neutnorm[i] > 0.0 )neutnorm[i] = 1.0/neutnorm[i];
       }
     }   // end of initialization
     
     const G4double expxu = 82.;           // upper bound for arg. of exp
     const G4double expxl = -expxu;        // lower bound for arg. of exp
     G4ParticleDefinition *aNeutron = G4Neutron::Neutron();
     G4ParticleDefinition *aProton = G4Proton::Proton();
     G4ParticleDefinition *aKaonMinus = G4KaonMinus::KaonMinus();
     G4ParticleDefinition *aSigmaPlus = G4SigmaPlus::SigmaPlus();
     G4ParticleDefinition *aXiMinus = G4XiMinus::XiMinus();
     //
     // energetically possible to produce pion(s)  -->  inelastic scattering
     //
     G4double n, anpn;
     GetNormalizationConstant( availableEnergy, n, anpn );
     G4double ran = G4UniformRand();
     G4double dum, excs = 0.0;
     if( targetParticle.GetDefinition() == aProton )
     {
       counter = -1;
       for( np=0; np<numSec/3 && ran>=excs; ++np )
       {
         for( nneg=std::max(0,np-2); nneg<=(np+1) && ran>=excs; ++nneg )
         {
           for( nz=0; nz<numSec/3 && ran>=excs; ++nz )
           {
             if( ++counter < numMul )
             {
               nt = np+nneg+nz;
               if( nt>0 && nt<=numSec )
               {
                 test = G4Exp( std::min( expxu, std::max( expxl, -(pi/4.0)*(nt*nt)/(n*n) ) ) );
                 dum = (pi/anpn)*nt*protmul[counter]*protnorm[nt-1]/(2.0*n*n);
                 if( std::fabs(dum) < 1.0 )
                 {
                   if( test >= 1.0e-10 )excs += dum*test;
                 }
                 else
                   excs += dum*test;
               }
             }
           }
         }
       }
       if( ran >= excs )  // 3 previous loops continued to the end
       {
         quasiElastic = true;
         return;
       }
       np--; nneg--; nz--;
       //
       // number of secondary mesons determined by kno distribution
       // check for total charge of final state mesons to determine
       // the kind of baryons to be produced, taking into account
       // charge and strangeness conservation
       //
       if( np < nneg+1 )
       {
         if( np != nneg )   // charge mismatch
         {
           currentParticle.SetDefinitionAndUpdateE( aSigmaPlus );
           incidentHasChanged = true;
           //
           // correct the strangeness by replacing a pi- by a kaon-
           //
           vec.Initialize( 1 );
           G4ReactionProduct *p = new G4ReactionProduct;
           p->SetDefinition( aKaonMinus );
           (G4UniformRand() < 0.5) ? p->SetSide( -1 ) : p->SetSide( 1 );
           vec.SetElement( vecLen++, p );
           --nneg;
         }
       }
       else if( np == nneg+1 )
       {
         if( G4UniformRand() < 0.5 )
         {
           targetParticle.SetDefinitionAndUpdateE( aNeutron );
           targetHasChanged = true;
         }
         else
         {
           currentParticle.SetDefinitionAndUpdateE( aXiMinus );
           incidentHasChanged = true;
         }
       }
       else
       {
         currentParticle.SetDefinitionAndUpdateE( aXiMinus );
         incidentHasChanged = true;
         targetParticle.SetDefinitionAndUpdateE( aNeutron );
         targetHasChanged = true;
       }
     }
     else  // target must be a neutron
     {
       counter = -1;
       for( np=0; np<numSec/3 && ran>=excs; ++np )
       {
         for( nneg=std::max(0,np-1); nneg<=(np+2) && ran>=excs; ++nneg )
         {
           for( nz=0; nz<numSec/3 && ran>=excs; ++nz )
           {
             if( ++counter < numMul )
             {
               nt = np+nneg+nz;
               if( nt>0 && nt<=numSec )
               {
                 test = G4Exp( std::min( expxu, std::max( expxl, -(pi/4.0)*(nt*nt)/(n*n) ) ) );
                 dum = (pi/anpn)*nt*neutmul[counter]*neutnorm[nt-1]/(2.0*n*n);
                 if( std::fabs(dum) < 1.0 )
                 {
                   if( test >= 1.0e-10 )excs += dum*test;
                 }
                 else
                   excs += dum*test;
               }
             }
           }
         }
       }
       if( ran >= excs )  // 3 previous loops continued to the end
       {
         quasiElastic = true;
         return;
       }
       np--; nneg--; nz--;
       if( np < nneg )
       {
         if( np+1 == nneg )
         {
           targetParticle.SetDefinitionAndUpdateE( aProton );
           targetHasChanged = true;
         }
         else   // charge mismatch
         {
           currentParticle.SetDefinitionAndUpdateE( aSigmaPlus );
           incidentHasChanged = true;
           targetParticle.SetDefinitionAndUpdateE( aProton );
           targetHasChanged = true;
           //
           // correct the strangeness by replacing a pi- by a kaon-
           //
           vec.Initialize( 1 );
           G4ReactionProduct *p = new G4ReactionProduct;
           p->SetDefinition( aKaonMinus );
           (G4UniformRand() < 0.5) ? p->SetSide( -1 ) : p->SetSide( 1 );
           vec.SetElement( vecLen++, p );
           --nneg;
         }
       }
       else if( np == nneg )
       {
         if( G4UniformRand() >= 0.5 )
         {
           currentParticle.SetDefinitionAndUpdateE( aXiMinus );
           incidentHasChanged = true;
           targetParticle.SetDefinitionAndUpdateE( aProton );
           targetHasChanged = true;
         }
       }
       else
       {
         currentParticle.SetDefinitionAndUpdateE( aXiMinus );
         incidentHasChanged = true;
       }        
   }
 
   SetUpPions(np, nneg, nz, vec, vecLen);
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4RPGAntiXiZeroInelastic()

◆ ~G4RPGAntiXiZeroInelastic()

Member Function Documentation

◆ ApplyYourself()

◆ Cascade()