G4FTFModel Class Reference

#include <G4FTFModel.hh>

Inheritance diagram for G4FTFModel:

Public Member Functions
	G4FTFModel (const G4String &modelName="FTF")
	~G4FTFModel () override
G4V3DNucleus *	GetTargetNucleus () const
G4V3DNucleus *	GetWoundedNucleus () const override
G4V3DNucleus *	GetProjectileNucleus () const override
void	ModelDescription (std::ostream &) const override
	G4FTFModel (const G4FTFModel &right)=delete
const G4FTFModel &	operator= (const G4FTFModel &right)=delete
G4bool	operator== (const G4FTFModel &right) const =delete
G4bool	operator!= (const G4FTFModel &right) const =delete
Public Member Functions inherited from G4VPartonStringModel
	G4VPartonStringModel (const G4String &modelName="Parton String Model")
	~G4VPartonStringModel () override
	G4VPartonStringModel (const G4VPartonStringModel &right)=delete
const G4VPartonStringModel &	operator= (const G4VPartonStringModel &right)=delete
G4bool	operator== (const G4VPartonStringModel &right) const =delete
G4bool	operator!= (const G4VPartonStringModel &right) const =delete
void	SetFragmentationModel (G4VStringFragmentation *aModel)
G4KineticTrackVector *	Scatter (const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary) override
void	ModelDescription (std::ostream &outFile) const override
G4V3DNucleus *	GetProjectileNucleus () const override
Public Member Functions inherited from G4VHighEnergyGenerator
	G4VHighEnergyGenerator (const G4String &modelName="HighEnergyGenerator")
	~G4VHighEnergyGenerator () override
	G4VHighEnergyGenerator (const G4VHighEnergyGenerator &right)=delete
const G4VHighEnergyGenerator &	operator= (const G4VHighEnergyGenerator &right)=delete
G4bool	operator== (const G4VHighEnergyGenerator &right) const =delete
G4bool	operator!= (const G4VHighEnergyGenerator &right) const =delete
virtual G4V3DNucleus *	GetWoundedNucleus () const =0
virtual G4V3DNucleus *	GetProjectileNucleus () const
virtual G4KineticTrackVector *	Scatter (const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary)=0
void	ModelDescription (std::ostream &) const override
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

Protected Member Functions
void	Init (const G4Nucleus &aNucleus, const G4DynamicParticle &aProjectile) override
G4ExcitedStringVector *	GetStrings () override
Protected Member Functions inherited from G4VPartonStringModel
virtual void	Init (const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary)=0
virtual G4ExcitedStringVector *	GetStrings ()=0
G4bool	EnergyAndMomentumCorrector (G4KineticTrackVector *Output, G4LorentzVector &TotalCollisionMomentum)
Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)
G4bool	IsBlocked () const
void	Block ()

Additional Inherited Members
Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange
G4int	verboseLevel
G4double	theMinEnergy
G4double	theMaxEnergy
G4bool	isBlocked

Detailed Description

Definition at line 61 of file G4FTFModel.hh.

Constructor & Destructor Documentation

G4FTFModel() [1/2]

G4FTFModel::G4FTFModel

(

const G4String &

modelName = "FTF"

)

Definition at line 70 of file G4FTFModel.cc.

                                                  : 
  G4VPartonStringModel( modelName ),
  theExcitation( new G4DiffractiveExcitation() ),
  theElastic( new G4ElasticHNScattering() ),
  theAnnihilation( new G4FTFAnnihilation() )
{
  // ---> JVY theParameters = 0;
  theParameters = new G4FTFParameters();
  //
  NumberOfInvolvedNucleonsOfTarget = 0;
  NumberOfInvolvedNucleonsOfProjectile= 0;
  for ( G4int i = 0; i < 250; ++i ) {
    TheInvolvedNucleonsOfTarget[i] = 0;
    TheInvolvedNucleonsOfProjectile[i] = 0;
  }
 
  //LowEnergyLimit = 2000.0*MeV;
  LowEnergyLimit = 1000.0*MeV;
 
  HighEnergyInter = true;
 
  G4LorentzVector tmp( 0.0, 0.0, 0.0, 0.0 );
  ProjectileResidual4Momentum        = tmp;
  ProjectileResidualMassNumber       = 0;
  ProjectileResidualCharge           = 0;
  ProjectileResidualExcitationEnergy = 0.0;
 
  TargetResidual4Momentum            = tmp;
  TargetResidualMassNumber           = 0;
  TargetResidualCharge               = 0;
  TargetResidualExcitationEnergy     = 0.0;
 
  SetEnergyMomentumCheckLevels( 2.0*perCent, 150.0*MeV );
}

~G4FTFModel()

G4FTFModel::~G4FTFModel ( )

override

Definition at line 113 of file G4FTFModel.cc.

                        {
   // Because FTF model can be called for various particles
   //
   // ---> NOTE (JVY): This statement below is no longer true !!! 
   // theParameters must be erased at the end of each call.
   // Thus the delete is also in G4FTFModel::GetStrings() method.
   // ---> JVY
   //
   if ( theParameters   != 0 ) delete theParameters; 
   if ( theExcitation   != 0 ) delete theExcitation;
   if ( theElastic      != 0 ) delete theElastic; 
   if ( theAnnihilation != 0 ) delete theAnnihilation;
 
   // Erasing of strings created at annihilation.
   if ( theAdditionalString.size() != 0 ) {
     std::for_each( theAdditionalString.begin(), theAdditionalString.end(), 
                    DeleteVSplitableHadron() );
   }
   theAdditionalString.clear();
 
   // Erasing of target involved nucleons.
   if ( NumberOfInvolvedNucleonsOfTarget != 0 ) {
     for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; ++i ) {
       G4VSplitableHadron* aNucleon = TheInvolvedNucleonsOfTarget[i]->GetSplitableHadron();
       if ( aNucleon ) delete aNucleon;
     }
   }
 
   // Erasing of projectile involved nucleons.
   if ( NumberOfInvolvedNucleonsOfProjectile != 0 ) {
     for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; ++i ) {
       G4VSplitableHadron* aNucleon = TheInvolvedNucleonsOfProjectile[i]->GetSplitableHadron();
       if ( aNucleon ) delete aNucleon;
     }
   }
}

G4FTFModel() [2/2]

G4FTFModel::G4FTFModel ( const G4FTFModel &  right )

delete

Member Function Documentation

GetProjectileNucleus()

G4V3DNucleus * G4FTFModel::GetProjectileNucleus ( ) const

inlineoverridevirtual

Reimplemented from G4VHighEnergyGenerator.

Definition at line 201 of file G4FTFModel.hh.

                                                            {
  return theParticipants.GetProjectileNucleus();
}

Referenced by GetStrings().

GetStrings()

G4ExcitedStringVector * G4FTFModel::GetStrings ( )

overrideprotectedvirtual

Implements G4VPartonStringModel.

Definition at line 290 of file G4FTFModel.cc.

                                              { 
 
  #ifdef debugFTFmodel
  G4cout << "G4FTFModel::GetStrings() " << G4endl;
  #endif
 
  G4ExcitedStringVector* theStrings = new G4ExcitedStringVector;
  theParticipants.GetList( theProjectile, theParameters );
  StoreInvolvedNucleon(); 
 
  G4bool Success( true );
 
  if ( HighEnergyInter ) {
    ReggeonCascade(); 
 
    #ifdef debugFTFmodel
    G4cout << "FTF PutOnMassShell " << G4endl;
    #endif
 
    Success = PutOnMassShell(); 
 
    #ifdef debugFTFmodel
    G4cout << "FTF PutOnMassShell Success?  " << Success << G4endl;
    #endif
 
  }
 
  #ifdef debugFTFmodel
  G4cout << "FTF ExciteParticipants " << G4endl;
  #endif
 
  if ( Success ) Success = ExciteParticipants();
 
  #ifdef debugFTFmodel
  G4cout << "FTF ExciteParticipants Success? " << Success << G4endl;
  #endif
 
  if ( Success ) {       
 
    #ifdef debugFTFmodel
    G4cout << "FTF BuildStrings ";
    #endif
 
    BuildStrings( theStrings );
 
    #ifdef debugFTFmodel
    G4cout << "FTF BuildStrings " << theStrings << " OK" << G4endl
           << "FTF GetResiduals of Nuclei " << G4endl;
    #endif
 
    GetResiduals();
 
    /*
    if ( theParameters != 0 ) {
      delete theParameters;
      theParameters = 0;
    }
    */
  } else if ( ! GetProjectileNucleus() ) {
    // Erase the hadron projectile
    std::vector< G4VSplitableHadron* > primaries;
    theParticipants.StartLoop();
    while ( theParticipants.Next() ) {  /* Loop checking, 10.08.2015, A.Ribon */
      const G4InteractionContent& interaction = theParticipants.GetInteraction();
      // Do not allow for duplicates
      if ( primaries.end() == 
           std::find( primaries.begin(), primaries.end(), interaction.GetProjectile() ) ) {
        primaries.push_back( interaction.GetProjectile() );
      }
    }
    std::for_each( primaries.begin(), primaries.end(), DeleteVSplitableHadron() );
    primaries.clear();
  }
 
  // Cleaning of the memory
  G4VSplitableHadron* aNucleon = 0;
 
  // Erase the projectile nucleons
  for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; ++i ) {
    aNucleon = TheInvolvedNucleonsOfProjectile[i]->GetSplitableHadron();
    if ( aNucleon ) delete aNucleon;
  } 
  NumberOfInvolvedNucleonsOfProjectile = 0;
 
  // Erase the target nucleons
  for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; ++i ) {
    aNucleon = TheInvolvedNucleonsOfTarget[i]->GetSplitableHadron();
    if ( aNucleon ) delete aNucleon;
  } 
  NumberOfInvolvedNucleonsOfTarget = 0;
 
  #ifdef debugFTFmodel
  G4cout << "End of FTF. Go to fragmentation" << G4endl
         << "To continue - enter 1, to stop - ^C" << G4endl;
  //G4int Uzhi; G4cin >> Uzhi;
  #endif
 
  theParticipants.Clean();
 
  return theStrings;
}

GetTargetNucleus()

G4V3DNucleus * G4FTFModel::GetTargetNucleus ( ) const

inline

Definition at line 197 of file G4FTFModel.hh.

                                                        {
  return theParticipants.GetWoundedNucleus();
}

GetWoundedNucleus()

G4V3DNucleus * G4FTFModel::GetWoundedNucleus ( ) const

inlineoverridevirtual

Implements G4VHighEnergyGenerator.

Definition at line 193 of file G4FTFModel.hh.

                                                         {
  return theParticipants.GetWoundedNucleus();
}

Init()

void G4FTFModel::Init ( const G4Nucleus &  aNucleus, const G4DynamicParticle &  aProjectile  )

overrideprotectedvirtual

Implements G4VPartonStringModel.

Definition at line 153 of file G4FTFModel.cc.

                                                                                       {
 
  theProjectile = aProjectile;  
 
  G4double PlabPerParticle( 0.0 );  // Laboratory momentum Pz per particle/nucleon
 
  #ifdef debugFTFmodel
  G4cout << "FTF init Proj Name " << theProjectile.GetDefinition()->GetParticleName() << G4endl
         << "FTF init Proj Mass " << theProjectile.GetMass() 
         << " " << theProjectile.GetMomentum() << G4endl
         << "FTF init Proj B Q  " << theProjectile.GetDefinition()->GetBaryonNumber()
         << " " << (G4int) theProjectile.GetDefinition()->GetPDGCharge() << G4endl 
         << "FTF init Target A Z " << aNucleus.GetA_asInt() 
         << " " << aNucleus.GetZ_asInt() << G4endl;
  #endif
 
  theParticipants.Clean();
 
  theParticipants.SetProjectileNucleus( 0 );
 
  G4LorentzVector tmp( 0.0, 0.0, 0.0, 0.0 );
  ProjectileResidualMassNumber       = 0;
  ProjectileResidualCharge           = 0;
  ProjectileResidualExcitationEnergy = 0.0;
  ProjectileResidual4Momentum        = tmp;
 
  TargetResidualMassNumber       = aNucleus.GetA_asInt();
  TargetResidualCharge           = aNucleus.GetZ_asInt();
  TargetResidualExcitationEnergy = 0.0;
  TargetResidual4Momentum        = tmp;
  G4double TargetResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()
                                ->GetIonMass( TargetResidualCharge, TargetResidualMassNumber );
 
  TargetResidual4Momentum.setE( TargetResidualMass );
 
  if ( std::abs( theProjectile.GetDefinition()->GetBaryonNumber() ) <= 1 ) { 
    // Projectile is a hadron : meson or baryon
    PlabPerParticle = theProjectile.GetMomentum().z();
    ProjectileResidualMassNumber = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
    ProjectileResidualCharge = G4int( theProjectile.GetDefinition()->GetPDGCharge() );
    ProjectileResidualExcitationEnergy = 0.0;
    //G4double ProjectileResidualMass = theProjectile.GetMass();
    ProjectileResidual4Momentum.setVect( theProjectile.GetMomentum() );
    ProjectileResidual4Momentum.setE( theProjectile.GetTotalEnergy() );
    if ( PlabPerParticle < LowEnergyLimit ) {
      HighEnergyInter = false;
    } else {
      HighEnergyInter = true;
    }
  } else {
    if ( theProjectile.GetDefinition()->GetBaryonNumber() > 1 ) { 
      // Projectile is a nucleus
      theParticipants.InitProjectileNucleus(theProjectile.GetDefinition()->GetBaryonNumber(),
                                            G4int(theProjectile.GetDefinition()->GetPDGCharge()));
      ProjectileResidualMassNumber = theProjectile.GetDefinition()->GetBaryonNumber();
      ProjectileResidualCharge = G4int( theProjectile.GetDefinition()->GetPDGCharge() );
      PlabPerParticle = theProjectile.GetMomentum().z() / 
                        theProjectile.GetDefinition()->GetBaryonNumber();
      if ( PlabPerParticle < LowEnergyLimit ) {
        HighEnergyInter = false;
      } else {
        HighEnergyInter = true;
      }
    } else if ( theProjectile.GetDefinition()->GetBaryonNumber() < -1 ) { 
      // Projectile is an anti-nucleus
      theParticipants.InitProjectileNucleus( 
          std::abs( theProjectile.GetDefinition()->GetBaryonNumber() ),
          std::abs( G4int( theProjectile.GetDefinition()->GetPDGCharge() ) ) );
      theParticipants.GetProjectileNucleus()->StartLoop();
      G4Nucleon* aNucleon;
      while ( ( aNucleon = theParticipants.GetProjectileNucleus()->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( aNucleon->GetDefinition() == G4Proton::Proton() ) {
          aNucleon->SetParticleType( G4AntiProton::AntiProton() ); 
        } else if ( aNucleon->GetDefinition() == G4Neutron::Neutron() ) {
          aNucleon->SetParticleType( G4AntiNeutron::AntiNeutron() );
        } 
      }
      ProjectileResidualMassNumber = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
      ProjectileResidualCharge = std::abs( G4int(theProjectile.GetDefinition()->GetPDGCharge()) );
      PlabPerParticle = theProjectile.GetMomentum().z() /
                        std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
      if ( PlabPerParticle < LowEnergyLimit ) {
        HighEnergyInter = false;
      } else {
        HighEnergyInter = true;
      }
    }
 
    G4ThreeVector BoostVector = theProjectile.GetMomentum() / theProjectile.GetTotalEnergy();
    theParticipants.GetProjectileNucleus()->DoLorentzBoost( BoostVector );
    theParticipants.GetProjectileNucleus()->DoLorentzContraction( BoostVector );
    ProjectileResidualExcitationEnergy = 0.0;
    //G4double ProjectileResidualMass = theProjectile.GetMass();
    ProjectileResidual4Momentum.setVect( theProjectile.GetMomentum() );
    ProjectileResidual4Momentum.setE( theProjectile.GetTotalEnergy() );
  }
 
  // Init target nucleus
  theParticipants.Init( aNucleus.GetA_asInt(), aNucleus.GetZ_asInt() );
  //theParticipants.Init( aNucleus.GetA_asInt(), 0 ); // For h+neutron
 
  /*
  if ( theParameters != 0 ) delete theParameters;
  theParameters = new G4FTFParameters( theProjectile.GetDefinition(), aNucleus.GetA_asInt(),
                                       aNucleus.GetZ_asInt(), PlabPerParticle );
  */
 
  // reset/recalculate everything for the new interaction
  //
 
  theParameters->InitForInteraction( theProjectile.GetDefinition(), aNucleus.GetA_asInt(),
                                     aNucleus.GetZ_asInt(), PlabPerParticle ); 
 
  if ( theAdditionalString.size() != 0 ) {
    std::for_each( theAdditionalString.begin(), theAdditionalString.end(), 
                   DeleteVSplitableHadron() );
  }
  theAdditionalString.clear();
 
  #ifdef debugFTFmodel
  G4cout << "FTF end of Init" << G4endl << G4endl;
  #endif
 
  // In the case of Hydrogen target, for non-ion hadron projectiles,
  // do NOT simulate quasi-elastic (by forcing to 0 the probability of
  // elastic scatering in theParameters - which is used only by FTF).
  // This is necessary because in this case quasi-elastic on a target nucleus
  // with only one nucleon would be identical to the hadron elastic scattering,
  // and the latter is already included in the elastic process 
  // (i.e. G4HadronElasticProcess).
  if ( std::abs( theProjectile.GetDefinition()->GetBaryonNumber() ) <= 1  &&
       aNucleus.GetA_asInt() < 2 ) theParameters->SetProbabilityOfElasticScatt( 0.0 );
}

ModelDescription()

void G4FTFModel::ModelDescription ( std::ostream &  desc ) const

overridevirtual

Reimplemented from G4VHighEnergyGenerator.

Definition at line 3069 of file G4FTFModel.cc.

                                                          {
  desc << "                 FTF (Fritiof) Model               \n" 
       << "The FTF model is based on the well-known FRITIOF   \n"
       << "model (B. Andersson et al., Nucl. Phys. B281, 289  \n"
       << "(1987)). Its first program implementation was given\n"
       << "by B. Nilsson-Almquist and E. Stenlund (Comp. Phys.\n"
       << "Comm. 43, 387 (1987)). The Fritiof model assumes   \n"
       << "that all hadron-hadron interactions are binary     \n"
       << "reactions, h_1+h_2->h_1'+h_2' where h_1' and h_2'  \n"
       << "are excited states of the hadrons with continuous  \n"
       << "mass spectra. The excited hadrons are considered as\n"
       << "QCD-strings, and the corresponding LUND-string     \n"
       << "fragmentation model is applied for a simulation of \n"
       << "their decays.                                      \n"
       << "   The Fritiof model assumes that in the course of \n"
       << "a hadron-nucleus interaction a string originated   \n"
       << "from the projectile can interact with various intra\n"
       << "nuclear nucleons and becomes into highly excited   \n"
       << "states. The probability of multiple interactions is\n"
       << "calculated in the Glauber approximation. A cascading\n"
       << "of secondary particles was neglected as a rule. Due\n"
       << "to these, the original Fritiof model fails to des- \n"
       << "cribe a nuclear destruction and slow particle spectra.\n"
       << "   In order to overcome the difficulties we enlarge\n"
       << "the model by the reggeon theory inspired model of  \n"
       << "nuclear desctruction (Kh. Abdel-Waged and V.V. Uzhi-\n"
       << "nsky, Phys. Atom. Nucl. 60, 828 (1997); Yad. Fiz. 60, 925\n"
       << "(1997)). Momenta of the nucleons ejected from a nuc-\n"
       << "leus in the reggeon cascading are sampled according\n"
       << "to a Fermi motion algorithm presented in (EMU-01   \n"
       << "Collaboration (M.I. Adamovich et al.) Zeit. fur Phys.\n"
       << "A358, 337 (1997)).                                 \n"
       << "   New features were also added to the Fritiof model\n"
       << "implemented in Geant4: a simulation of elastic had-\n"
       << "ron-nucleon scatterings, a simulation of binary \n"
       << "reactions like NN>NN* in hadron-nucleon interactions,\n"
       << "a separate simulation of single diffractive and non-\n"
       << " diffractive events. These allowed to describe after\n"
       << "model parameter tuning a wide set of experimental  \n"
       << "data.                                              \n";
}

operator!=()

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

delete

operator=()

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

delete

operator==()

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

delete

---

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

• G4FTFModel.hh
• G4FTFModel.cc