G4CRCoalescence Class Reference

#include <G4CRCoalescence.hh>

Inheritance diagram for G4CRCoalescence:

Public Member Functions
	G4CRCoalescence ()
	~G4CRCoalescence () override
	G4CRCoalescence (const G4CRCoalescence &right)=delete
const G4CRCoalescence &	operator= (const G4CRCoalescence &right)=delete
G4bool	operator== (const G4CRCoalescence &right) const =delete
G4bool	operator!= (const G4CRCoalescence &right) const =delete
void	SetP0Coalescence (const G4HadProjectile &thePrimary, G4String)
void	GenerateDeuterons (G4ReactionProductVector *result)
Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")
virtual	~G4HadronicInteraction ()
virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
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)
G4int	GetVerboseLevel () const
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
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 &)
virtual void	InitialiseModel ()
	G4HadronicInteraction (const G4HadronicInteraction &right)=delete
const G4HadronicInteraction &	operator= (const G4HadronicInteraction &right)=delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4HadronicInteraction &right) const =delete

Additional Inherited Members
Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)
G4bool	IsBlocked () const
void	Block ()
Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange
G4int	verboseLevel
G4double	theMinEnergy
G4double	theMaxEnergy
G4bool	isBlocked

Detailed Description

Definition at line 77 of file G4CRCoalescence.hh.

Constructor & Destructor Documentation

G4CRCoalescence() [1/2]

G4CRCoalescence::G4CRCoalescence ( )

explicit

Definition at line 82 of file G4CRCoalescence.cc.

                                 : G4HadronicInteraction("G4CRCoalescence" ),
  fP0_d( 0.0 ), fP0_dbar( 0.0 ), secID( -1 ) {
  secID = G4PhysicsModelCatalog::GetModelID( "model_G4CRCoalescence" );
}

~G4CRCoalescence()

G4CRCoalescence::~G4CRCoalescence ( )

override

Definition at line 88 of file G4CRCoalescence.cc.

{}

G4CRCoalescence() [2/2]

G4CRCoalescence::G4CRCoalescence ( const G4CRCoalescence & right )

delete

Member Function Documentation

GenerateDeuterons()

void G4CRCoalescence::GenerateDeuterons

(

G4ReactionProductVector *

result

)

Definition at line 113 of file G4CRCoalescence.cc.

                                                                         {
  // Deuteron clusters are made with the first nucleon pair that fulfills
  // the coalescence conditions, starting with the protons.
  // A deuteron is a pair (i,j) where i is the proton and j the neutron in current event
  // with the relative momentum less than p0 (i.e. within a sphere of radius p0).
  // The same applies for antideuteron clusters, with antiprotons and antineutrons,
  // instead of protons and neutrons, respectively.
  
  // Vectors of index-position and 3-momentum pairs for, respectively:
  // protons, neutrons, antiprotons and antineutrons
  std::vector< std::pair< G4int, G4ThreeVector > > proton;
  std::vector< std::pair< G4int, G4ThreeVector > > neutron;
  std::vector< std::pair< G4int, G4ThreeVector > > antiproton;
  std::vector< std::pair< G4int, G4ThreeVector > > antineutron;
  for ( unsigned int i = 0; i < result->size(); ++i ) {
    G4int pdgid = result->operator[](i)->GetDefinition()->GetPDGEncoding();
    if ( pdgid == 2212 ) {  // proton
      proton.push_back( std::make_pair( i, result->operator[](i)->GetMomentum() ) );
      result->erase( result->begin() + i );
    }
  }
  for ( unsigned int i = 0; i < result->size(); ++i ) {
    G4int pdgid = result->operator[](i)->GetDefinition()->GetPDGEncoding();
    if ( pdgid == 2112 ) {  // neutron
      neutron.push_back( std::make_pair( i, result->operator[](i)->GetMomentum() ) );
      result->erase( result->begin() + i );
    }
  }
  for ( unsigned int i = 0; i < result->size(); ++i ) {
    G4int pdgid = result->operator[](i)->GetDefinition()->GetPDGEncoding();
    if ( pdgid == -2212 ) {  // antiproton
      antiproton.push_back( std::make_pair( i, result->operator[](i)->GetMomentum() ) );
      result->erase( result->begin() + i );
    }
  }
  for ( unsigned int i = 0; i < result->size(); ++i ) {
    G4int pdgid = result->operator[](i)->GetDefinition()->GetPDGEncoding();
    if ( pdgid == -2112 ) {  // antineutron
      antineutron.push_back( std::make_pair( i, result->operator[](i)->GetMomentum() ) );
      result->erase( result->begin() + i );
    }
  }
 
  for ( unsigned int i = 0; i < proton.size(); ++i ) {  // loop over protons 
    if ( proton.at(i).first == -1 ) continue;
    G4ThreeVector p1 = proton.at(i).second;
    int partner1 = FindPartner( p1, G4Proton::Proton()->GetPDGMass(), neutron,
                G4Neutron::Neutron()->GetPDGMass(), 1 );
    if ( partner1 == -1 ) {  // if no partner found, then the proton is a final-state secondary
        G4ParticleDefinition* prt = G4ParticleTable::GetParticleTable()->FindParticle( "proton" );
        G4ReactionProduct* finalp = new G4ReactionProduct;
        finalp->SetDefinition( prt );
        G4double massp = prt->GetPDGMass();
        G4double totalEnergy = std::sqrt( p1.mag()*p1.mag() + massp*massp );    
        finalp->SetMomentum( p1 );
        finalp->SetTotalEnergy( totalEnergy );
        finalp->SetMass( massp );   
        result->push_back( finalp );        
        continue;
    }
    G4ThreeVector p2 = neutron.at(partner1).second;
    PushDeuteron( p1, p2, 1, result );
    neutron.at(partner1).first = -1;  // tag the bound neutron
  }
 
  for ( unsigned int i = 0; i < neutron.size(); ++i ) {  // loop over neutrons 
    if ( neutron.at(i).first == -1 ) continue;  // Skip already bound neutron, else it is a final-state secondary
    G4ParticleDefinition* nrt = G4ParticleTable::GetParticleTable()->FindParticle( "neutron" );
    G4ReactionProduct* finaln = new G4ReactionProduct;
    finaln->SetDefinition( nrt );
    G4ThreeVector p2 = neutron.at(i).second;
    G4double massn = nrt->GetPDGMass();
    G4double totalEnergy = std::sqrt( p2.mag()*p2.mag() + massn*massn );    
    finaln->SetMomentum( p2 );
    finaln->SetTotalEnergy( totalEnergy );
    finaln->SetMass( massn );   
    result->push_back( finaln );            
  }
 
  for ( unsigned int i = 0; i < antiproton.size(); ++i ) {  // loop over antiprotons
    if ( antiproton.at(i).first == -1 ) continue;
    G4ThreeVector p1 = antiproton.at(i).second;
    int partner1 = FindPartner( p1, G4Proton::Proton()->GetPDGMass(), antineutron,
                G4Neutron::Neutron()->GetPDGMass(), -1 );
    if ( partner1 == -1 ) {  // if no partner found, then the antiproton is a final-state secondary
        G4ParticleDefinition* pbar = G4ParticleTable::GetParticleTable()->FindAntiParticle( "proton" );
        G4ReactionProduct* finalpbar = new G4ReactionProduct;
        finalpbar->SetDefinition( pbar );
        G4double massp = pbar->GetPDGMass();
        G4double totalEnergy = std::sqrt( p1.mag()*p1.mag() + massp*massp );
        finalpbar->SetMomentum( p1 );
        finalpbar->SetTotalEnergy( totalEnergy );
        finalpbar->SetMass( massp );    
        result->push_back( finalpbar );     
        continue;
    }
    G4ThreeVector p2 = antineutron.at(partner1).second;
    PushDeuteron( p1, p2, -1, result );
    antineutron.at(partner1).first = -1;  // tag the bound antineutron
  }
 
  for ( unsigned int i = 0; i < antineutron.size(); ++i ) {  // loop over antineutrons 
    if ( antineutron.at(i).first == -1 ) continue;  // Skip already bound antineutron, else it is a final-state secondary
    G4ParticleDefinition* nbar = G4ParticleTable::GetParticleTable()->FindAntiParticle( "neutron" );
    G4ReactionProduct* finalnbar = new G4ReactionProduct;
    finalnbar->SetDefinition( nbar );
    G4ThreeVector p2 = antineutron.at(i).second;
    G4double massn = nbar->GetPDGMass();
    G4double totalEnergy = std::sqrt( p2.mag()*p2.mag() + massn*massn );    
    finalnbar->SetMomentum( p2 );
    finalnbar->SetTotalEnergy( totalEnergy );
    finalnbar->SetMass( massn );    
    result->push_back( finalnbar );         
  }
}

Referenced by G4TheoFSGenerator::ApplyYourself().

operator!=()

G4bool G4CRCoalescence::operator!= ( const G4CRCoalescence & right ) const

delete

operator=()

const G4CRCoalescence & G4CRCoalescence::operator= ( const G4CRCoalescence & right )

delete

operator==()

G4bool G4CRCoalescence::operator== ( const G4CRCoalescence & right ) const

delete

SetP0Coalescence()

void G4CRCoalescence::SetP0Coalescence	(	const G4HadProjectile &	thePrimary,
		G4String	)

Definition at line 91 of file G4CRCoalescence.cc.

                                                                                      {
  // Note by A.R. : in the present version, the coalescence parameters are set only for
  //                proton projectile. If we want to extend this coalescence algorithm
  //                for other applications, besides cosmic rays, we need to set these
  //                coalescence parameters also for all projectiles.
  //                (Note that the method "GenerateDeuterons", instead, can be already used
  //                 as it is for all projectiles.)
  fP0_dbar = 0.0;
  fP0_d    = 0.0;
  if ( thePrimary.GetDefinition()->GetPDGEncoding() == 2212 ) {  // proton
    G4double mproj = thePrimary.GetDefinition()->GetPDGMass();
    G4double pz = thePrimary.Get4Momentum().z();
    G4double ekin = std::sqrt( pz*pz + mproj*mproj ) - mproj;
    if ( ekin > 10.0 ) {
      fP0_dbar = 130.0 / ( 1.0 + std::exp( 21.6 - std::log( 0.001*ekin )/0.089 ) );  // set p0 for antideuteron 
      fP0_d    = 118.1 * ( 1.0 + std::exp( 5.53 - std::log( 0.001*ekin )/0.43 ) );   // set p0 for deuteron
    }
  }
  //G4cout << "Coalescence parameter p0 deuteron / antideuteron: " << fP0_d << " / " << fP0_dbar << G4endl;
}

Referenced by G4TheoFSGenerator::ApplyYourself().

---

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

• G4CRCoalescence.hh
• G4CRCoalescence.cc