#include <G4FTFModel.hh>

Inheritance diagram for G4FTFModel:

Data Structures
struct	CommonVariables

Public Member Functions
void	ActivateFor (const G4Element *anElement)

void	ActivateFor (const G4Material *aMaterial)

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

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

void	DeActivateFor (const G4Element *anElement)

void	DeActivateFor (const G4Material *aMaterial)

	G4FTFModel (const G4FTFModel &right)=delete

	G4FTFModel (const G4String &modelName="FTF")

G4double	GetBmax () const

G4double	GetBmin () const

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

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

G4double	GetImpactParameter () const

G4double	GetMaxEnergy () const

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

G4double	GetMinEnergy () const

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

const G4String &	GetModelName () const

G4int	GetNumberOfNNcollisions () const

G4int	GetNumberOfProjectileSpectatorNucleons () const

G4int	GetNumberOfTargetSpectatorNucleons () const

G4V3DNucleus *	GetProjectileNucleus () const override

G4double	GetRecoilEnergyThreshold () const

G4V3DNucleus *	GetTargetNucleus () const

G4int	GetVerboseLevel () const

G4V3DNucleus *	GetWoundedNucleus () const override

virtual void	InitialiseModel ()

virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)

G4bool	IsBlocked (const G4Element *anElement) const

G4bool	IsBlocked (const G4Material *aMaterial) const

void	ModelDescription (std::ostream &) const override

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

G4bool	operator!= (const G4HadronicInteraction &right) const =delete

G4bool	operator!= (const G4VHighEnergyGenerator &right) const =delete

G4bool	operator!= (const G4VPartonStringModel &right) const =delete

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

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

G4bool	operator== (const G4HadronicInteraction &right) const =delete

G4bool	operator== (const G4VHighEnergyGenerator &right) const =delete

G4bool	operator== (const G4VPartonStringModel &right) const =delete

G4bool	SampleBinInterval () const

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

G4KineticTrackVector *	Scatter (const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary) override

void	SetBminBmax (const G4double bmin_value, const G4double bmax_value)

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

void	SetFragmentationModel (G4VStringFragmentation *aModel)

void	SetImpactParameter (const G4double b_value)

void	SetMaxEnergy (const G4double anEnergy)

void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)

void	SetMinEnergy (G4double anEnergy)

void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)

void	SetRecoilEnergyThreshold (G4double val)

void	SetVerboseLevel (G4int value)

	~G4FTFModel () override

Protected Member Functions
void	Block ()

G4bool	EnergyAndMomentumCorrector (G4KineticTrackVector *Output, G4LorentzVector &TotalCollisionMomentum)

G4ExcitedStringVector *	GetStrings () override

void	Init (const G4Nucleus &aNucleus, const G4DynamicParticle &aProjectile) override

G4bool	IsBlocked () const

void	SetModelName (const G4String &nam)

Protected Attributes
G4bool	isBlocked

G4double	theMaxEnergy

G4double	theMinEnergy

G4HadFinalState	theParticleChange

G4int	verboseLevel

Private Member Functions
G4bool	AdjustNucleons (G4VSplitableHadron SelectedAntiBaryon, G4Nucleon ProjectileNucleon, G4VSplitableHadron SelectedTargetNucleon, G4Nucleon TargetNucleon, G4bool Annihilation)

void	AdjustNucleonsAlgorithm_afterSampling (G4int interactionCase, G4VSplitableHadron SelectedAntiBaryon, G4VSplitableHadron SelectedTargetNucleon, CommonVariables &common)

G4int	AdjustNucleonsAlgorithm_beforeSampling (G4int interactionCase, G4VSplitableHadron SelectedAntiBaryon, G4Nucleon ProjectileNucleon, G4VSplitableHadron SelectedTargetNucleon, G4Nucleon TargetNucleon, G4bool Annihilation, CommonVariables &common)

G4bool	AdjustNucleonsAlgorithm_Sampling (G4int interactionCase, CommonVariables &common)

void	BuildStrings (G4ExcitedStringVector *strings)

G4bool	CheckKinematics (const G4double sValue, const G4double sqrtS, const G4double projectileMass2, const G4double targetMass2, const G4double nucleusY, const G4bool isProjectileNucleus, const G4int numberOfInvolvedNucleons, G4Nucleon *involvedNucleons[], G4double &targetWminus, G4double &projectileWplus, G4bool &success)

G4bool	ComputeNucleusProperties (G4V3DNucleus *nucleus, G4LorentzVector &nucleusMomentum, G4LorentzVector &residualMomentum, G4double &sumMasses, G4double &residualExcitationEnergy, G4double &residualMass, G4int &residualMassNumber, G4int &residualCharge)

G4bool	ExciteParticipants ()

G4bool	FinalizeKinematics (const G4double w, const G4bool isProjectileNucleus, const G4LorentzRotation &boostFromCmsToLab, const G4double residualMass, const G4int residualMassNumber, const G4int numberOfInvolvedNucleons, G4Nucleon *involvedNucleons[], G4LorentzVector &residual4Momentum)

G4ThreeVector	GaussianPt (G4double AveragePt2, G4double maxPtSquare) const

G4bool	GenerateDeltaIsobar (const G4double sqrtS, const G4int numberOfInvolvedNucleons, G4Nucleon *involvedNucleons[], G4double &sumMasses)

void	GetResiduals ()

G4bool	PutOnMassShell ()

void	ReggeonCascade ()

G4bool	SamplingNucleonKinematics (G4double averagePt2, const G4double maxPt2, G4double dCor, G4V3DNucleus nucleus, const G4LorentzVector &pResidual, const G4double residualMass, const G4int residualMassNumber, const G4int numberOfInvolvedNucleons, G4Nucleon involvedNucleons[], G4double &mass2)

void	StoreInvolvedNucleon ()

Private Attributes
G4double	Bimpact

G4bool	BinInterval

G4double	Bmax

G4double	Bmin

std::pair< G4double, G4double >	epCheckLevels

G4bool	HighEnergyInter

G4double	LowEnergyLimit

G4int	NumberOfInvolvedNucleonsOfProjectile

G4int	NumberOfInvolvedNucleonsOfTarget

G4int	NumberOfNNcollisions

G4int	NumberOfProjectileSpectatorNucleons

G4int	NumberOfTargetSpectatorNucleons

G4LorentzVector	ProjectileResidual4Momentum

G4int	ProjectileResidualCharge

G4double	ProjectileResidualExcitationEnergy

G4int	ProjectileResidualLambdaNumber

G4int	ProjectileResidualMassNumber

G4double	recoilEnergyThreshold

G4HadronicInteractionRegistry *	registry

G4VStringFragmentation *	stringFragmentationModel

G4LorentzVector	TargetResidual4Momentum

G4int	TargetResidualCharge

G4double	TargetResidualExcitationEnergy

G4int	TargetResidualMassNumber

std::vector< G4VSplitableHadron * >	theAdditionalString

G4FTFAnnihilation *	theAnnihilation

std::vector< const G4Material * >	theBlockedList

std::vector< const G4Element * >	theBlockedListElements

G4ElasticHNScattering *	theElastic

G4DiffractiveExcitation *	theExcitation

G4Nucleon *	TheInvolvedNucleonsOfProjectile [250]

G4Nucleon *	TheInvolvedNucleonsOfTarget [250]

std::vector< std::pair< G4double, const G4Material * > >	theMaxEnergyList

std::vector< std::pair< G4double, const G4Element * > >	theMaxEnergyListElements

std::vector< std::pair< G4double, const G4Material * > >	theMinEnergyList

std::vector< std::pair< G4double, const G4Element * > >	theMinEnergyListElements

G4String	theModelName

G4FTFParameters *	theParameters

G4FTFParticipants	theParticipants

G4ReactionProduct	theProjectile

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;
  ProjectileResidualLambdaNumber     = 0;
  ProjectileResidualExcitationEnergy = 0.0;
 
  TargetResidual4Momentum            = tmp;
  TargetResidualMassNumber           = 0;
  TargetResidualCharge               = 0;
  TargetResidualExcitationEnergy     = 0.0;
 
  Bimpact = -1.0;
  BinInterval = false;
  Bmin = 0.0; 
  Bmax = 0.0;
  NumberOfProjectileSpectatorNucleons = 0;
  NumberOfTargetSpectatorNucleons = 0;
  NumberOfNNcollisions = 0;
 
  SetEnergyMomentumCheckLevels( 2.0*perCent, 150.0*MeV );
}

References Bimpact, BinInterval, Bmax, Bmin, HighEnergyInter, LowEnergyLimit, MeV, NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, NumberOfNNcollisions, NumberOfProjectileSpectatorNucleons, NumberOfTargetSpectatorNucleons, perCent, ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualLambdaNumber, ProjectileResidualMassNumber, G4HadronicInteraction::SetEnergyMomentumCheckLevels(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, TargetResidualMassNumber, TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, and theParameters.

◆ ~G4FTFModel()

G4FTFModel::~G4FTFModel ( )

override

Definition at line 122 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;
     }
   }
}

References G4Nucleon::GetSplitableHadron(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, theAdditionalString, theAnnihilation, theElastic, theExcitation, TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, and theParameters.

◆ G4FTFModel() [2/2]

G4FTFModel::G4FTFModel ( const G4FTFModel & right )

delete

Member Function Documentation

◆ ActivateFor() [1/2]

void G4HadronicInteraction::ActivateFor ( const G4Element * anElement )

inlineinherited

Definition at line 128 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), anElement);
    SetMinEnergy(GetMinEnergy(), anElement);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ ActivateFor() [2/2]

void G4HadronicInteraction::ActivateFor ( const G4Material * aMaterial )

inlineinherited

Definition at line 120 of file G4HadronicInteraction.hh.

  { 
    Block(); 
    SetMaxEnergy(GetMaxEnergy(), aMaterial);
    SetMinEnergy(GetMinEnergy(), aMaterial);
  }

References G4HadronicInteraction::Block(), G4HadronicInteraction::GetMaxEnergy(), G4HadronicInteraction::GetMinEnergy(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ AdjustNucleons()

G4bool G4FTFModel::AdjustNucleons	(	G4VSplitableHadron *	SelectedAntiBaryon,
		G4Nucleon *	ProjectileNucleon,
		G4VSplitableHadron *	SelectedTargetNucleon,
		G4Nucleon *	TargetNucleon,
		G4bool	Annihilation
	)

private

Definition at line 1032 of file G4FTFModel.cc.

                                                         {
 
  #ifdef debugAdjust
  G4cout << "AdjustNucleons ---------------------------------------" << G4endl
         << "Proj is nucleus? " << GetProjectileNucleus() << G4endl
         << "Proj 4mom " << SelectedAntiBaryon->Get4Momentum() << G4endl
         << "Targ 4mom " << SelectedTargetNucleon->Get4Momentum() << G4endl
         << "Pr ResidualMassNumber Pr ResidualCharge Pr ResidualExcitationEnergy "
         << ProjectileResidualMassNumber << " " << ProjectileResidualCharge << " "
         << ProjectileResidualExcitationEnergy << G4endl
         << "Tr ResidualMassNumber Tr ResidualCharge Tr ResidualExcitationEnergy  "
         << TargetResidualMassNumber << " " << TargetResidualCharge << " "
         << TargetResidualExcitationEnergy << G4endl
         << "Collis. pr tr " << SelectedAntiBaryon->GetSoftCollisionCount()
         << SelectedTargetNucleon->GetSoftCollisionCount() << G4endl;
  #endif
 
  if ( SelectedAntiBaryon->GetSoftCollisionCount() != 0  && 
       SelectedTargetNucleon->GetSoftCollisionCount() != 0 ) {
    return true; // Selected hadrons were adjusted before.   
  }
 
  G4int interactionCase = 0;
  if (    ( ! GetProjectileNucleus()  &&
            SelectedAntiBaryon->GetSoftCollisionCount() == 0  &&
            SelectedTargetNucleon->GetSoftCollisionCount() == 0 )
       ||
          ( SelectedAntiBaryon->GetSoftCollisionCount() != 0  && 
            SelectedTargetNucleon->GetSoftCollisionCount() == 0 ) ) {
    // The case of hadron-nucleus interactions, or
    // the case when projectile nuclear nucleon participated in
    // a collision, but target nucleon did not participate.
    interactionCase = 1;
    #ifdef debugAdjust 
    G4cout << "case 1, hA prcol=0 trcol=0, AA prcol#0 trcol=0" << G4endl;
    #endif
    if ( TargetResidualMassNumber < 1 ) {
      return false;
    }
    if ( SelectedAntiBaryon->Get4Momentum().rapidity() < TargetResidual4Momentum.rapidity() ) {
      return false;
    }
    if ( TargetResidualMassNumber == 1 ) {
      TargetResidualMassNumber       = 0;
      TargetResidualCharge           = 0;
      TargetResidualExcitationEnergy = 0.0;
      SelectedTargetNucleon->Set4Momentum( TargetResidual4Momentum );
      TargetResidual4Momentum = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
      return true;
    }
  } else if ( SelectedAntiBaryon->GetSoftCollisionCount() == 0  && 
              SelectedTargetNucleon->GetSoftCollisionCount() != 0 ) {
    // It is assumed that in the case there is ProjectileResidualNucleus
    interactionCase = 2;
    #ifdef debugAdjust
    G4cout << "case 2,  prcol=0 trcol#0" << G4endl;
    #endif
    if ( ProjectileResidualMassNumber < 1 ) {
      return false;
    }
    if ( ProjectileResidual4Momentum.rapidity() <= 
         SelectedTargetNucleon->Get4Momentum().rapidity() ) {
      return false;
    }
    if ( ProjectileResidualMassNumber == 1 ) {
      ProjectileResidualMassNumber       = 0;
      ProjectileResidualCharge           = 0;
      ProjectileResidualExcitationEnergy = 0.0;
      SelectedAntiBaryon->Set4Momentum( ProjectileResidual4Momentum );        
      ProjectileResidual4Momentum = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
      return true;
    }
  } else {  // It has to be a nucleus-nucleus interaction
    interactionCase = 3;
    #ifdef debugAdjust
    G4cout << "case 3,  prcol=0 trcol=0" << G4endl;
    #endif
    if ( ! GetProjectileNucleus() ) {
      return false;
    }
    #ifdef debugAdjust
    G4cout << "Proj res Init " << ProjectileResidual4Momentum << G4endl
           << "Targ res Init " << TargetResidual4Momentum << G4endl
           << "ProjectileResidualMassNumber ProjectileResidualCharge (ProjectileResidualLambdaNumber)" 
           << ProjectileResidualMassNumber << " " << ProjectileResidualCharge
           << " (" << ProjectileResidualLambdaNumber << ") " << G4endl
           << "TargetResidualMassNumber TargetResidualCharge " << TargetResidualMassNumber
           << " " << TargetResidualCharge << G4endl;
    #endif
  }
 
  CommonVariables common;
  G4int returnCode = AdjustNucleonsAlgorithm_beforeSampling( interactionCase, SelectedAntiBaryon,
                                                             ProjectileNucleon, SelectedTargetNucleon,
                                                             TargetNucleon, Annihilation, common );
  G4bool returnResult = false;
  if ( returnCode == 0 ) {
    returnResult = true;  // Successfully ended: no need of extra work
  } else if ( returnCode == 1 ) {
    // The part before sampling has been successfully completed: now try the sampling
    returnResult = AdjustNucleonsAlgorithm_Sampling( interactionCase, common );
    if ( returnResult ) {  // The sampling has completed successfully: do the last part
      AdjustNucleonsAlgorithm_afterSampling( interactionCase, SelectedAntiBaryon, 
                                             SelectedTargetNucleon, common ); 
    }
  }
 
  return returnResult;
}

References AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), AdjustNucleonsAlgorithm_Sampling(), common(), G4cout, G4endl, G4VSplitableHadron::Get4Momentum(), GetProjectileNucleus(), G4VSplitableHadron::GetSoftCollisionCount(), ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualLambdaNumber, ProjectileResidualMassNumber, CLHEP::HepLorentzVector::rapidity(), G4VSplitableHadron::Set4Momentum(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, and TargetResidualMassNumber.

Referenced by ExciteParticipants().

◆ AdjustNucleonsAlgorithm_afterSampling()

void G4FTFModel::AdjustNucleonsAlgorithm_afterSampling	(	G4int	interactionCase,
		G4VSplitableHadron *	SelectedAntiBaryon,
		G4VSplitableHadron *	SelectedTargetNucleon,
		G4FTFModel::CommonVariables &	common
	)

private

Definition at line 1836 of file G4FTFModel.cc.

                                                                                            {
  // Third of the three utility methods used only by AdjustNucleons: do the final kinematics
  // and transform back.
 
  // New projectile
  if ( interactionCase == 1 ) {
    common.Pprojectile.setPz( common.Pzprojectile );  
    common.Pprojectile.setE( common.Eprojectile );
  } else if ( interactionCase == 2 ) {
    common.Pprojectile.setPx( common.PtNucleon.x() ); 
    common.Pprojectile.setPy( common.PtNucleon.y() );
    common.Pprojectile.setPz( common.PzprojectileNucleon );
    common.Pprojectile.setE( common.EprojectileNucleon ); 
  } else if ( interactionCase == 3 ) {
    common.Pprojectile.setPx( common.PtNucleonP.x() );
    common.Pprojectile.setPy( common.PtNucleonP.y() );
    common.Pprojectile.setPz( common.PzprojectileNucleon );
    common.Pprojectile.setE( common.EprojectileNucleon );
  }
  #ifdef debugAdjust
  G4cout << "Proj after in CMS " << common.Pprojectile << G4endl;
  #endif
  common.Pprojectile.transform( common.toLab );
  SelectedAntiBaryon->Set4Momentum( common.Pprojectile );
  #ifdef debugAdjust
  G4cout << "Proj after in Lab " << common.Pprojectile << G4endl;
  #endif
 
  // New target nucleon
  if ( interactionCase == 1 ) {
    common.Ptarget.setPx( common.PtNucleon.x() );
    common.Ptarget.setPy( common.PtNucleon.y() );
    common.Ptarget.setPz( common.PztargetNucleon );
    common.Ptarget.setE( common.EtargetNucleon ); 
  } else if ( interactionCase == 2 ) {
    common.Ptarget.setPz( common.Pztarget ); 
    common.Ptarget.setE( common.Etarget );
  } else if ( interactionCase == 3 ) {
    common.Ptarget.setPx( common.PtNucleonT.x() );
    common.Ptarget.setPy( common.PtNucleonT.y() );
    common.Ptarget.setPz( common.PztargetNucleon );
    common.Ptarget.setE( common.EtargetNucleon );
  }
  #ifdef debugAdjust
  G4cout << "Targ after in CMS " << common.Ptarget << G4endl;
  #endif
  common.Ptarget.transform( common.toLab );
  SelectedTargetNucleon->Set4Momentum( common.Ptarget );
  #ifdef debugAdjust
  G4cout << "Targ after in Lab " << common.Ptarget << G4endl;
  #endif
 
  // New target residual
  if ( interactionCase == 1  ||  interactionCase == 3 ) {
    TargetResidualMassNumber       = common.TResidualMassNumber;
    TargetResidualCharge           = common.TResidualCharge;
    TargetResidualExcitationEnergy = common.TResidualExcitationEnergy;
    #ifdef debugAdjust
    G4cout << "TargetResidualMassNumber TargetResidualCharge TargetResidualExcitationEnergy "
           << TargetResidualMassNumber << " " << TargetResidualCharge << " "
           << TargetResidualExcitationEnergy << G4endl;
    #endif
    if ( TargetResidualMassNumber != 0 ) {
      G4double Mt2 = 0.0;
      if ( interactionCase == 1 ) {
        Mt2 = sqr( common.TResidualMass ) + common.PtResidual.mag2();
        TargetResidual4Momentum.setPx( common.PtResidual.x() );
        TargetResidual4Momentum.setPy( common.PtResidual.y() );
      } else {  // interactionCase == 3
        Mt2 = sqr( common.TResidualMass ) + common.PtResidualT.mag2();
        TargetResidual4Momentum.setPx( common.PtResidualT.x() );
        TargetResidual4Momentum.setPy( common.PtResidualT.y() );
      }
      G4double Pz = - common.WminusTarget * common.XminusResidual / 2.0
                    + Mt2 / ( 2.0 * common.WminusTarget * common.XminusResidual );
      G4double E =    common.WminusTarget * common.XminusResidual / 2.0 
                    + Mt2 / ( 2.0 * common.WminusTarget * common.XminusResidual );
      TargetResidual4Momentum.setPz( Pz );
      TargetResidual4Momentum.setE( E ) ;
      TargetResidual4Momentum.transform( common.toLab );
    } else {
      TargetResidual4Momentum = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
    }
    #ifdef debugAdjust
    G4cout << "Tr N R " << common.Ptarget << G4endl << "       " << TargetResidual4Momentum << G4endl;
    #endif
  }
 
  // New projectile residual
  if ( interactionCase == 2  ||  interactionCase == 3 ) {
    if ( interactionCase == 2 ) {
      ProjectileResidualMassNumber       = common.TResidualMassNumber;
      ProjectileResidualCharge           = common.TResidualCharge;
      ProjectileResidualExcitationEnergy = common.TResidualExcitationEnergy;
    } else {  // interactionCase == 3
      ProjectileResidualMassNumber       = common.PResidualMassNumber;
      ProjectileResidualCharge           = common.PResidualCharge;
      ProjectileResidualExcitationEnergy = common.PResidualExcitationEnergy;
    }
    #ifdef debugAdjust
    G4cout << "ProjectileResidualMassNumber ProjectileResidualCharge ProjectileResidualExcitationEnergy "
           << ProjectileResidualMassNumber << " " << ProjectileResidualCharge << " "
           << ProjectileResidualExcitationEnergy << G4endl;
    #endif
    if ( ProjectileResidualMassNumber != 0 ) {
      G4double Mt2 = 0.0;
      if ( interactionCase == 2 ) {
        Mt2 = sqr( common.TResidualMass ) + common.PtResidual.mag2();
        ProjectileResidual4Momentum.setPx( common.PtResidual.x() );
        ProjectileResidual4Momentum.setPy( common.PtResidual.y() );
      } else {  // interactionCase == 3
        Mt2 = sqr( common.PResidualMass ) + common.PtResidualP.mag2();
        ProjectileResidual4Momentum.setPx( common.PtResidualP.x() );
        ProjectileResidual4Momentum.setPy( common.PtResidualP.y() );
      }
      G4double Pz =   common.WplusProjectile * common.XplusResidual / 2.0
                    - Mt2 / ( 2.0 * common.WplusProjectile * common.XplusResidual );
      G4double E  =   common.WplusProjectile * common.XplusResidual / 2.0 
                    + Mt2 / ( 2.0 * common.WplusProjectile * common.XplusResidual );
      ProjectileResidual4Momentum.setPz( Pz );
      ProjectileResidual4Momentum.setE( E );
      ProjectileResidual4Momentum.transform( common.toLab );
    } else {
      ProjectileResidual4Momentum = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
    }
    #ifdef debugAdjust
    G4cout << "Pr N R " << common.Pprojectile << G4endl 
           << "       " << ProjectileResidual4Momentum << G4endl;
    #endif
  }
 
}

References common(), G4cout, G4endl, ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualMassNumber, G4VSplitableHadron::Set4Momentum(), CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPx(), CLHEP::HepLorentzVector::setPy(), CLHEP::HepLorentzVector::setPz(), sqr(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, TargetResidualMassNumber, and CLHEP::HepLorentzVector::transform().

Referenced by AdjustNucleons().

◆ AdjustNucleonsAlgorithm_beforeSampling()

G4int G4FTFModel::AdjustNucleonsAlgorithm_beforeSampling	(	G4int	interactionCase,
		G4VSplitableHadron *	SelectedAntiBaryon,
		G4Nucleon *	ProjectileNucleon,
		G4VSplitableHadron *	SelectedTargetNucleon,
		G4Nucleon *	TargetNucleon,
		G4bool	Annihilation,
		G4FTFModel::CommonVariables &	common
	)

private

Definition at line 1148 of file G4FTFModel.cc.

                                                                                              {
  // First of the three utility methods used only by AdjustNucleons: prepare for sampling.
  // This method returns an integer code - instead of a boolean, with the following meaning:
  //   "0" : successfully ended and nothing else needs to be done (i.e. no sampling);
  //   "1" : successfully completed, but the work needs to be continued, i.e. try to sample;
  //  "99" : unsuccessfully ended, nothing else can be done.
  G4int returnCode = 99;
 
  G4double ExcitationEnergyPerWoundedNucleon = theParameters->GetExcitationEnergyPerWoundedNucleon();
 
  // some checks and initializations
  if ( interactionCase == 1 ) {
    common.Psum = SelectedAntiBaryon->Get4Momentum() + TargetResidual4Momentum;
    #ifdef debugAdjust
    G4cout << "Targ res Init " << TargetResidual4Momentum << G4endl;
    #endif
    common.Pprojectile = SelectedAntiBaryon->Get4Momentum();
  } else if ( interactionCase == 2 ) {
    common.Psum = ProjectileResidual4Momentum + SelectedTargetNucleon->Get4Momentum();
    common.Pprojectile = ProjectileResidual4Momentum;
  } else if ( interactionCase == 3 ) {
    common.Psum = ProjectileResidual4Momentum + TargetResidual4Momentum; 
    common.Pprojectile = ProjectileResidual4Momentum;
  }
 
  // transform momenta to cms and then rotate parallel to z axis
  common.toCms = G4LorentzRotation( -1*common.Psum.boostVector() ); 
  common.Ptmp = common.toCms * common.Pprojectile;
  common.toCms.rotateZ( -1*common.Ptmp.phi() );
  common.toCms.rotateY( -1*common.Ptmp.theta() );
  common.Pprojectile.transform( common.toCms );
  common.toLab = common.toCms.inverse();
  common.SqrtS = common.Psum.mag();
  common.S = sqr( common.SqrtS );
 
  // get properties of the target residual and/or projectile residual
  G4bool Stopping = false;
  if ( interactionCase == 1 ) {
    common.TResidualMassNumber = TargetResidualMassNumber - 1;
    common.TResidualCharge =   TargetResidualCharge 
                             - G4int( TargetNucleon->GetDefinition()->GetPDGCharge() );
    common.TResidualExcitationEnergy =   TargetResidualExcitationEnergy
                                       - ExcitationEnergyPerWoundedNucleon*G4Log( G4UniformRand() );
    if ( common.TResidualMassNumber <= 1 ) {
      common.TResidualExcitationEnergy = 0.0;
    }
    if ( common.TResidualMassNumber != 0 ) {
      common.TResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()
                             ->GetIonMass( common.TResidualCharge, common.TResidualMassNumber );
    }
    common.TNucleonMass = TargetNucleon->GetDefinition()->GetPDGMass();
    common.SumMasses =   SelectedAntiBaryon->Get4Momentum().mag() + common.TNucleonMass 
                       + common.TResidualMass;
    #ifdef debugAdjust
    G4cout << "Annihilation " << Annihilation << G4endl;
    #endif
  } else if ( interactionCase == 2 ) {
    common.Ptarget = common.toCms * SelectedTargetNucleon->Get4Momentum();
    common.TResidualMassNumber = ProjectileResidualMassNumber - 1;
    common.TResidualCharge =   ProjectileResidualCharge 
                             - std::abs( G4int(ProjectileNucleon->GetDefinition()->GetPDGCharge()) );
    common.TResidualExcitationEnergy =   ProjectileResidualExcitationEnergy 
                                       - ExcitationEnergyPerWoundedNucleon*G4Log( G4UniformRand() );
    if ( common.TResidualMassNumber <= 1 ) {
      common.TResidualExcitationEnergy = 0.0;
    }
    if ( common.TResidualMassNumber != 0 ) {
      common.TResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()
                             ->GetIonMass( common.TResidualCharge, common.TResidualMassNumber );
    }
    common.TNucleonMass = ProjectileNucleon->GetDefinition()->GetPDGMass();
    common.SumMasses =   SelectedTargetNucleon->Get4Momentum().mag() + common.TNucleonMass 
                       + common.TResidualMass;
    #ifdef debugAdjust
    G4cout << "SelectedTN.mag() PNMass + PResidualMass " 
           << SelectedTargetNucleon->Get4Momentum().mag() << " " 
           << common.TNucleonMass << " " << common.TResidualMass << G4endl;
    #endif
  } else if ( interactionCase == 3 ) {
    common.Ptarget = common.toCms * TargetResidual4Momentum;
    common.PResidualMassNumber = ProjectileResidualMassNumber - 1;
    common.PResidualCharge =   ProjectileResidualCharge 
                             - std::abs( G4int(ProjectileNucleon->GetDefinition()->GetPDGCharge()) );
    common.PResidualLambdaNumber = ProjectileResidualLambdaNumber;
    if ( ProjectileNucleon->GetDefinition() == G4Lambda::Definition()  ||
     ProjectileNucleon->GetDefinition() == G4AntiLambda::Definition() ) {
      --common.PResidualLambdaNumber;  
    }
    common.PResidualExcitationEnergy =   ProjectileResidualExcitationEnergy 
                                       - ExcitationEnergyPerWoundedNucleon*G4Log( G4UniformRand() );
    if ( common.PResidualMassNumber <= 1 ) {
      common.PResidualExcitationEnergy = 0.0;
    }
    if ( common.PResidualMassNumber != 0 ) {
      if ( common.PResidualLambdaNumber > 0 ) {
        common.PResidualMass = G4HyperNucleiProperties::GetNuclearMass( common.PResidualMassNumber,
                                    common.PResidualCharge,
                                    common.PResidualLambdaNumber );
      } else {
    common.PResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()
                           ->GetIonMass( common.PResidualCharge, common.PResidualMassNumber );
      }
    }
    common.PNucleonMass = ProjectileNucleon->GetDefinition()->GetPDGMass();  // On-shell (anti-)nucleon mass 
    common.TResidualMassNumber = TargetResidualMassNumber - 1;
    common.TResidualCharge =   TargetResidualCharge
                             - G4int( TargetNucleon->GetDefinition()->GetPDGCharge() );
    common.TResidualExcitationEnergy =   TargetResidualExcitationEnergy 
                                       - ExcitationEnergyPerWoundedNucleon*G4Log( G4UniformRand() );
    if ( common.TResidualMassNumber <= 1 ) {
      common.TResidualExcitationEnergy = 0.0;
    }
    if ( common.TResidualMassNumber != 0 ) {
      common.TResidualMass = G4ParticleTable::GetParticleTable()->GetIonTable()
                             ->GetIonMass( common.TResidualCharge, common.TResidualMassNumber );
    }
    common.TNucleonMass = TargetNucleon->GetDefinition()->GetPDGMass();  // On-shell nucleon mass
    common.SumMasses =   common.PNucleonMass + common.PResidualMass + common.TNucleonMass 
                       + common.TResidualMass;
    #ifdef debugAdjust
    G4cout << "PNucleonMass PResidualMass TNucleonMass TResidualMass " << common.PNucleonMass 
           << " " << common.PResidualMass << " " << common.TNucleonMass << " " 
           << common.TResidualMass << G4endl
           << "PResidualExcitationEnergy " << common.PResidualExcitationEnergy << G4endl
           << "TResidualExcitationEnergy " << common.TResidualExcitationEnergy << G4endl;
    #endif
  }  // End-if on interactionCase
 
  if ( ! Annihilation ) {
    if ( common.SqrtS < common.SumMasses ) {
      #ifdef debugAdjust
      G4cout << "SqrtS < SumMasses " << common.SqrtS << " " << common.SumMasses << G4endl;
      #endif
      return returnCode;  // Unsuccessfully ended, nothing else can be done
    } 
    if ( interactionCase == 1  ||  interactionCase == 2 ) {
      if ( common.SqrtS < common.SumMasses + common.TResidualExcitationEnergy ) {
        #ifdef debugAdjust
        G4cout << "TResidualExcitationEnergy : before " << common.TResidualExcitationEnergy << G4endl;
        #endif
        common.TResidualExcitationEnergy = common.SqrtS - common.SumMasses;
        #ifdef debugAdjust
        G4cout << "TResidualExcitationEnergy : after " << common.TResidualExcitationEnergy << G4endl;
        #endif
        Stopping = true;
        return returnCode;  // unsuccessfully ended, nothing else can be done
      }
    } else if ( interactionCase == 3 ) {
      #ifdef debugAdjust
      G4cout << "SqrtS < SumMasses + PResidualExcitationEnergy + TResidualExcitationEnergy "
             << common.SqrtS << " " << common.SumMasses + common.PResidualExcitationEnergy + common.TResidualExcitationEnergy
             << G4endl;
      #endif
      if ( common.SqrtS <   common.SumMasses + common.PResidualExcitationEnergy
                          + common.TResidualExcitationEnergy ) { 
        Stopping = true;
        if ( common.PResidualExcitationEnergy <= 0.0 ) {
          common.TResidualExcitationEnergy = common.SqrtS - common.SumMasses;
        } else if ( common.TResidualExcitationEnergy <= 0.0 ) {
          common.PResidualExcitationEnergy = common.SqrtS - common.SumMasses;
        } else {
          G4double Fraction = ( common.SqrtS - common.SumMasses )
            /  ( common.PResidualExcitationEnergy + common.TResidualExcitationEnergy );
          common.PResidualExcitationEnergy *= Fraction;
          common.TResidualExcitationEnergy *= Fraction;
        }
      }
    }
  }  // End-if on ! Annihilation
 
  if ( Annihilation ) {
    #ifdef debugAdjust
    G4cout << "SqrtS < SumMasses - TNucleonMass " << common.SqrtS << " " 
           << common.SumMasses - common.TNucleonMass << G4endl;
    #endif
    if ( common.SqrtS < common.SumMasses - common.TNucleonMass ) {
      return returnCode;  // unsuccessfully ended, nothing else can be done
    } 
    #ifdef debugAdjust
    G4cout << "SqrtS < SumMasses " << common.SqrtS << " " << common.SumMasses << G4endl;
    #endif
    if ( common.SqrtS < common.SumMasses ) {
      if ( interactionCase == 2  ||  interactionCase == 3 ) {
        common.TResidualExcitationEnergy = 0.0;
      }  
      common.TNucleonMass =   common.SqrtS - ( common.SumMasses - common.TNucleonMass )
                            - common.TResidualExcitationEnergy;  // Off-shell nucleon mass 
      #ifdef debugAdjust
      G4cout << "TNucleonMass " << common.TNucleonMass << G4endl;
      #endif
      common.SumMasses = common.SqrtS - common.TResidualExcitationEnergy;
      Stopping = true;
      #ifdef debugAdjust
      G4cout << "SqrtS < SumMasses " << common.SqrtS << " " << common.SumMasses << G4endl;
      #endif
    }
    if ( interactionCase == 1  ||  interactionCase == 2 ) {
      if ( common.SqrtS < common.SumMasses + common.TResidualExcitationEnergy ) {
        common.TResidualExcitationEnergy = common.SqrtS - common.SumMasses; 
        Stopping = true;
      }
    } else if ( interactionCase == 3 ) {
      if ( common.SqrtS <   common.SumMasses + common.PResidualExcitationEnergy
                          + common.TResidualExcitationEnergy ) {
        Stopping = true;
        if ( common.PResidualExcitationEnergy <= 0.0 ) {
          common.TResidualExcitationEnergy = common.SqrtS - common.SumMasses;
        } else if ( common.TResidualExcitationEnergy <= 0.0 ) {
          common.PResidualExcitationEnergy = common.SqrtS - common.SumMasses;
        } else {
          G4double Fraction = ( common.SqrtS - common.SumMasses ) / 
            ( common.PResidualExcitationEnergy + common.TResidualExcitationEnergy );
          common.PResidualExcitationEnergy *= Fraction;
          common.TResidualExcitationEnergy *= Fraction;
        }
      }
    }
  }  // End-if on Annihilation
 
  #ifdef debugAdjust
  G4cout << "Stopping " << Stopping << G4endl;
  #endif
 
  if ( Stopping ) {
    // All 3-momenta of particles = 0
    common.Ptmp.setPx( 0.0 ); common.Ptmp.setPy( 0.0 ); common.Ptmp.setPz( 0.0 );
    // New projectile
    if ( interactionCase == 1 ) {
      common.Ptmp.setE( SelectedAntiBaryon->Get4Momentum().mag() );
    } else if ( interactionCase == 2 ) {
      common.Ptmp.setE( common.TNucleonMass );
    } else if ( interactionCase == 3 ) {
      common.Ptmp.setE( common.PNucleonMass );
    }
    #ifdef debugAdjust
    G4cout << "Proj stop " << common.Ptmp << G4endl;
    #endif
    common.Pprojectile = common.Ptmp; 
    common.Pprojectile.transform( common.toLab );  // From center-of-mass to Lab frame
    //---AR-Jul2019 : To avoid unphysical projectile (anti-)fragments at rest, save the
    //                original momentum of the anti-baryon in the center-of-mass frame.
    G4LorentzVector saveSelectedAntiBaryon4Momentum = SelectedAntiBaryon->Get4Momentum();
    saveSelectedAntiBaryon4Momentum.transform( common.toCms );  // From Lab to center-of-mass frame
    //---
    SelectedAntiBaryon->Set4Momentum( common.Pprojectile );
    // New target nucleon
    if ( interactionCase == 1  ||  interactionCase == 3 ) {
      common.Ptmp.setE( common.TNucleonMass );
    } else if ( interactionCase == 2 ) {
      common.Ptmp.setE( SelectedTargetNucleon->Get4Momentum().mag() );
    }
    #ifdef debugAdjust
    G4cout << "Targ stop " << common.Ptmp << G4endl;
    #endif
    common.Ptarget = common.Ptmp; 
    common.Ptarget.transform( common.toLab );  // From center-of-mass to Lab frame
    //---AR-Jul2019 : To avoid unphysical target fragments at rest, save the original
    //                momentum of the target nucleon in the center-of-mass frame.
    G4LorentzVector saveSelectedTargetNucleon4Momentum = SelectedTargetNucleon->Get4Momentum();
    saveSelectedTargetNucleon4Momentum.transform( common.toCms );  // From Lab to center-of-mass frame
    //---
    SelectedTargetNucleon->Set4Momentum( common.Ptarget );
    // New target residual
    if ( interactionCase == 1  ||  interactionCase == 3 ) {
      common.Ptmp.setPx( 0.0 ); common.Ptmp.setPy( 0.0 ); common.Ptmp.setPz( 0.0 );
      TargetResidualMassNumber       = common.TResidualMassNumber;
      TargetResidualCharge           = common.TResidualCharge;
      TargetResidualExcitationEnergy = common.TResidualExcitationEnergy;
      //---AR-Jul2019 : To avoid unphysical target fragments at rest, use the saved
      //                original momentum of the target nucleon (instead of setting 0).
      //                This is a rough and simple approach!
      //common.Ptmp.setE( common.TResidualMass + TargetResidualExcitationEnergy );
      common.Ptmp.setPx( -saveSelectedTargetNucleon4Momentum.x() ); 
      common.Ptmp.setPy( -saveSelectedTargetNucleon4Momentum.y() ); 
      common.Ptmp.setPz( -saveSelectedTargetNucleon4Momentum.z() );
      common.Ptmp.setE( std::sqrt( sqr( common.TResidualMass + TargetResidualExcitationEnergy ) + common.Ptmp.vect().mag2() ) ); 
      //---
      #ifdef debugAdjust
      G4cout << "Targ Resi stop " << common.Ptmp << G4endl;
      #endif
      common.Ptmp.transform( common.toLab );  // From center-of-mass to Lab frame
      TargetResidual4Momentum = common.Ptmp;
    }
    // New projectile residual
    if ( interactionCase == 2  ||  interactionCase == 3 ) {
      common.Ptmp.setPx( 0.0 ); common.Ptmp.setPy( 0.0 ); common.Ptmp.setPz( 0.0 );
      if ( interactionCase == 2 ) {
        ProjectileResidualMassNumber       = common.TResidualMassNumber;
        ProjectileResidualCharge           = common.TResidualCharge;
    ProjectileResidualLambdaNumber     = 0;  // The target nucleus and its residual are never hypernuclei
        ProjectileResidualExcitationEnergy = common.TResidualExcitationEnergy;
        common.Ptmp.setE( common.TResidualMass + ProjectileResidualExcitationEnergy ); 
      } else {
        ProjectileResidualMassNumber       = common.PResidualMassNumber;
        ProjectileResidualCharge           = common.PResidualCharge;
    ProjectileResidualLambdaNumber     = common.PResidualLambdaNumber;
        ProjectileResidualExcitationEnergy = common.PResidualExcitationEnergy;
        //---AR-Jul2019 : To avoid unphysical projectile (anti-)fragments at rest, use the
        //                saved original momentum of the anti-baryon (instead of setting 0).
        //                This is a rough and simple approach!
        //common.Ptmp.setE( common.PResidualMass + ProjectileResidualExcitationEnergy );
        common.Ptmp.setPx( -saveSelectedAntiBaryon4Momentum.x() ); 
        common.Ptmp.setPy( -saveSelectedAntiBaryon4Momentum.y() ); 
        common.Ptmp.setPz( -saveSelectedAntiBaryon4Momentum.z() );
        common.Ptmp.setE( std::sqrt( sqr( common.PResidualMass + ProjectileResidualExcitationEnergy ) + common.Ptmp.vect().mag2() ) ); 
        //---
      }
      #ifdef debugAdjust
      G4cout << "Proj Resi stop " << common.Ptmp << G4endl;
      #endif
      common.Ptmp.transform( common.toLab );  // From center-of-mass to Lab frame
      ProjectileResidual4Momentum = common.Ptmp;
    }
    return returnCode = 0;  // successfully ended and nothing else needs to be done (i.e. no sampling)
  }  // End-if on Stopping
 
  // Initializations before sampling
  if ( interactionCase == 1 ) {
    common.Mprojectile  = common.Pprojectile.mag();
    common.M2projectile = common.Pprojectile.mag2();
    common.TResidual4Momentum = common.toCms * TargetResidual4Momentum;
    common.YtargetNucleus = common.TResidual4Momentum.rapidity();
    common.TResidualMass += common.TResidualExcitationEnergy;
  } else if ( interactionCase == 2 ) {
    common.Mtarget  = common.Ptarget.mag();
    common.M2target = common.Ptarget.mag2();
    common.TResidual4Momentum = common.toCms * ProjectileResidual4Momentum;
    common.YprojectileNucleus = common.TResidual4Momentum.rapidity();
    common.TResidualMass += common.TResidualExcitationEnergy;
  } else if ( interactionCase == 3 ) {
    common.PResidual4Momentum = common.toCms * ProjectileResidual4Momentum;
    common.YprojectileNucleus = common.PResidual4Momentum.rapidity();
    common.TResidual4Momentum = common.toCms*TargetResidual4Momentum;
    common.YtargetNucleus = common.TResidual4Momentum.rapidity();
    common.PResidualMass += common.PResidualExcitationEnergy;
    common.TResidualMass += common.TResidualExcitationEnergy;
  }
  #ifdef debugAdjust
  G4cout << "YprojectileNucleus " << common.YprojectileNucleus << G4endl;
  #endif
 
  return returnCode = 1;  // successfully completed, but the work needs to be continued, i.e. try to sample
}

References common(), G4AntiLambda::Definition(), G4Lambda::Definition(), G4cout, G4endl, G4Log(), G4UniformRand, G4VSplitableHadron::Get4Momentum(), G4Nucleon::GetDefinition(), G4FTFParameters::GetExcitationEnergyPerWoundedNucleon(), G4IonTable::GetIonMass(), G4ParticleTable::GetIonTable(), G4HyperNucleiProperties::GetNuclearMass(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), CLHEP::HepLorentzVector::mag(), ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualLambdaNumber, ProjectileResidualMassNumber, G4VSplitableHadron::Set4Momentum(), sqr(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, TargetResidualMassNumber, theParameters, CLHEP::HepLorentzVector::transform(), CLHEP::HepLorentzVector::x(), CLHEP::HepLorentzVector::y(), and CLHEP::HepLorentzVector::z().

Referenced by AdjustNucleons().

◆ AdjustNucleonsAlgorithm_Sampling()

G4bool G4FTFModel::AdjustNucleonsAlgorithm_Sampling	(	G4int	interactionCase,
		G4FTFModel::CommonVariables &	common
	)

private

Definition at line 1501 of file G4FTFModel.cc.

                                                                                         {
  // Second of the three utility methods used only by AdjustNucleons: do the sampling.
  // This method returns "false" if it fails to sample properly, else it returns "true".
 
  // Ascribing of the involved nucleons Pt and X 
  G4double Dcor = theParameters->GetDofNuclearDestruction();
  G4double DcorP = 0.0, DcorT = 0.0;
  if ( ProjectileResidualMassNumber != 0 ) DcorP = Dcor / G4double(ProjectileResidualMassNumber);
  if ( TargetResidualMassNumber != 0 )     DcorT = Dcor / G4double(TargetResidualMassNumber);
  G4double AveragePt2 = theParameters->GetPt2ofNuclearDestruction();
  G4double maxPtSquare = theParameters->GetMaxPt2ofNuclearDestruction();
 
  G4double ScaleFactor = 1.0;
  G4bool OuterSuccess = true;
  const G4int maxNumberOfLoops = 1000;
  const G4int maxNumberOfTries = 10000;
  G4int loopCounter = 0;
  G4int NumberOfTries = 0;
  do {  // Outmost do while loop
    OuterSuccess = true;
    G4bool loopCondition = false;
    do {  // Intermediate do while loop
      if ( NumberOfTries == 100*(NumberOfTries/100) ) { 
        // At large number of tries it would be better to reduce the values
        ScaleFactor /= 2.0;
        DcorP      *= ScaleFactor;
        DcorT      *= ScaleFactor;
        AveragePt2 *= ScaleFactor;
        #ifdef debugAdjust
        //G4cout << "NumberOfTries ScaleFactor " << NumberOfTries << " " << ScaleFactor << G4endl;
        #endif
      }
 
      // Some kinematics
      if ( interactionCase == 1 ) {
      } else if ( interactionCase == 2 ) {
        #ifdef debugAdjust
        G4cout << "ProjectileResidualMassNumber " << ProjectileResidualMassNumber << G4endl;
        #endif
        if ( ProjectileResidualMassNumber > 1 ) {
          common.PtNucleon = GaussianPt( AveragePt2, maxPtSquare );
        } else {
          common.PtNucleon = G4ThreeVector( 0.0, 0.0, 0.0 );
        }
        common.PtResidual = - common.PtNucleon;
        common.Mprojectile =   std::sqrt( sqr( common.TNucleonMass ) + common.PtNucleon.mag2() )
                             + std::sqrt( sqr( common.TResidualMass ) + common.PtResidual.mag2() );
        #ifdef debugAdjust
        G4cout << "SqrtS < Mtarget + Mprojectile " << common.SqrtS << "  " << common.Mtarget
               << " " << common.Mprojectile << " "  << common.Mtarget + common.Mprojectile << G4endl;
        #endif
        common.M2projectile = sqr( common.Mprojectile );
        if ( common.SqrtS < common.Mtarget + common.Mprojectile ) {
          OuterSuccess = false; 
          loopCondition = true;
          continue;
        }
      } else if ( interactionCase == 3 ) {
        if ( ProjectileResidualMassNumber > 1 ) {            
          common.PtNucleonP = GaussianPt( AveragePt2, maxPtSquare );
        } else {
          common.PtNucleonP = G4ThreeVector( 0.0, 0.0, 0.0 );
        }
        common.PtResidualP = - common.PtNucleonP;
        if ( TargetResidualMassNumber > 1 ) { 
          common.PtNucleonT = GaussianPt( AveragePt2, maxPtSquare );
        } else {
          common.PtNucleonT = G4ThreeVector( 0.0, 0.0, 0.0 );
        }
        common.PtResidualT = - common.PtNucleonT;
        common.Mprojectile =   std::sqrt( sqr( common.PNucleonMass )  + common.PtNucleonP.mag2() ) 
                             + std::sqrt( sqr( common.PResidualMass ) + common.PtResidualP.mag2() );
        common.M2projectile = sqr( common.Mprojectile );
        common.Mtarget =   std::sqrt( sqr( common.TNucleonMass )  + common.PtNucleonT.mag2() )
                         + std::sqrt( sqr( common.TResidualMass ) + common.PtResidualT.mag2() );
        common.M2target = sqr( common.Mtarget );
        if ( common.SqrtS < common.Mprojectile + common.Mtarget ) {
          OuterSuccess = false; 
          loopCondition = true;
          continue;
        }
      }  // End-if on interactionCase
 
      G4int numberOfTimesExecuteInnerLoop = 1;
      if ( interactionCase == 3 ) numberOfTimesExecuteInnerLoop = 2;
      for ( G4int iExecute = 0; iExecute < numberOfTimesExecuteInnerLoop; iExecute++ ) {
 
        G4bool InnerSuccess = true;
        G4bool isTargetToBeHandled = ( interactionCase == 1 || 
                                       ( interactionCase == 3 && iExecute == 1 ) );
        G4bool condition = false;
        if ( isTargetToBeHandled ) {
          condition = ( TargetResidualMassNumber > 1 );
    } else {  // Projectile to be handled
          condition = ( ProjectileResidualMassNumber > 1 );
        }
        if ( condition ) { 
          const G4int maxNumberOfInnerLoops = 1000;
          G4int innerLoopCounter = 0;
          do {  // Inner do while loop
            InnerSuccess = true;
            if ( isTargetToBeHandled ) {
              G4double Xcenter = 0.0;
              if ( interactionCase == 1 ) {
                common.PtNucleon = GaussianPt( AveragePt2, maxPtSquare );
                common.PtResidual = - common.PtNucleon;
                common.Mtarget =   std::sqrt( sqr( common.TNucleonMass )  + common.PtNucleon.mag2() ) 
                                 + std::sqrt( sqr( common.TResidualMass ) + common.PtResidual.mag2() );
                if ( common.SqrtS < common.Mprojectile + common.Mtarget ) {
                  InnerSuccess = false; 
                  continue;
                }
                Xcenter = std::sqrt( sqr( common.TNucleonMass ) + common.PtNucleon.mag2() ) 
                          / common.Mtarget;
              } else {
                Xcenter = std::sqrt( sqr( common.TNucleonMass ) + common.PtNucleonT.mag2() ) 
                          / common.Mtarget;
              }
              G4ThreeVector tmpX = GaussianPt( DcorT*DcorT, 1.0 );
              common.XminusNucleon = Xcenter + tmpX.x();
              if ( common.XminusNucleon <= 0.0  ||  common.XminusNucleon >= 1.0 ) {
                InnerSuccess = false; 
                continue;
              }
              common.XminusResidual = 1.0 - common.XminusNucleon;
            } else {  // Projectile to be handled
              G4ThreeVector tmpX = GaussianPt( DcorP*DcorP, 1.0 );
              G4double Xcenter = 0.0;
              if ( interactionCase == 2 ) {
                Xcenter = std::sqrt( sqr( common.TNucleonMass ) + common.PtNucleon.mag2() ) 
                          / common.Mprojectile;
              } else {
                Xcenter = std::sqrt( sqr( common.PNucleonMass ) + common.PtNucleonP.mag2() ) 
                          / common.Mprojectile;
              }
              common.XplusNucleon = Xcenter + tmpX.x();
              if ( common.XplusNucleon <= 0.0  ||  common.XplusNucleon >= 1.0 ) {
                InnerSuccess = false; 
                continue;
              }
              common.XplusResidual = 1.0 - common.XplusNucleon;
            }  // End-if on isTargetToBeHandled
          } while ( ( ! InnerSuccess ) &&                            // Inner do while loop
                      ++innerLoopCounter < maxNumberOfInnerLoops );  /* Loop checking, 10.08.2015, A.Ribon */ 
          if ( innerLoopCounter >= maxNumberOfInnerLoops ) {
            #ifdef debugAdjust
            G4cout << "BAD situation: forced exit of the inner while loop!" << G4endl;
            #endif
            return false;
          }
        } else {  // condition is false
          if ( isTargetToBeHandled ) {
            common.XminusNucleon  = 1.0;
            common.XminusResidual = 1.0;  // It must be 0, but in the calculation of Pz, E is problematic
          } else {  // Projectile to be handled
            common.XplusNucleon  = 1.0;
            common.XplusResidual = 1.0;   // It must be 0, but in the calculation of Pz, E is problematic
          } 
        }  // End-if on condition
 
      }  // End of for loop on iExecute
 
      if ( interactionCase == 1 ) {
        common.M2target =    ( sqr( common.TNucleonMass )  + common.PtNucleon.mag2() ) 
                             / common.XminusNucleon 
                          +  ( sqr( common.TResidualMass ) + common.PtResidual.mag2() ) 
                             / common.XminusResidual;
        loopCondition = ( common.SqrtS < common.Mprojectile + std::sqrt( common.M2target ) );
      } else if ( interactionCase == 2 ) {
        #ifdef debugAdjust
        G4cout << "TNucleonMass PtNucleon XplusNucleon " << common.TNucleonMass << " " 
               << common.PtNucleon << " " << common.XplusNucleon << G4endl
               << "TResidualMass PtResidual XplusResidual " << common.TResidualMass << " " 
               << common.PtResidual << "  " << common.XplusResidual << G4endl;
        #endif
        common.M2projectile =    ( sqr( common.TNucleonMass )  + common.PtNucleon.mag2() ) 
                                 / common.XplusNucleon 
                              +  ( sqr( common.TResidualMass ) + common.PtResidual.mag2() ) 
                                 / common.XplusResidual;
        #ifdef debugAdjust
        G4cout << "SqrtS < Mtarget + std::sqrt(M2projectile) " << common.SqrtS << "  " 
               << common.Mtarget << " " << std::sqrt( common.M2projectile ) << " "
               << common.Mtarget + std::sqrt( common.M2projectile ) << G4endl;
        #endif
        loopCondition = ( common.SqrtS < common.Mtarget + std::sqrt( common.M2projectile ) );
      } else if ( interactionCase == 3 ) {
        #ifdef debugAdjust
        G4cout << "PtNucleonP " << common.PtNucleonP << " " << common.PtResidualP << G4endl
               << "XplusNucleon XplusResidual " << common.XplusNucleon 
               << " " << common.XplusResidual << G4endl
               << "PtNucleonT " << common.PtNucleonT << " " << common.PtResidualT << G4endl
               << "XminusNucleon XminusResidual " << common.XminusNucleon 
               << " " << common.XminusResidual << G4endl;
        #endif
        common.M2projectile =   ( sqr( common.PNucleonMass ) + common.PtNucleonP.mag2() ) 
                                / common.XplusNucleon 
                              + ( sqr( common.PResidualMass) + common.PtResidualP.mag2() ) 
                                / common.XplusResidual;
        common.M2target =    ( sqr( common.TNucleonMass )  + common.PtNucleonT.mag2() ) 
                             / common.XminusNucleon 
                          +  ( sqr( common.TResidualMass ) + common.PtResidualT.mag2() ) 
                             / common.XminusResidual;
        loopCondition = ( common.SqrtS < (   std::sqrt( common.M2projectile ) 
                       + std::sqrt( common.M2target ) ) );
      }  // End-if on interactionCase
 
    } while ( loopCondition &&                       // Intermediate do while loop
              ++NumberOfTries < maxNumberOfTries );  /* Loop checking, 10.08.2015, A.Ribon */
    if ( NumberOfTries >= maxNumberOfTries ) { 
      #ifdef debugAdjust
      G4cout << "BAD situation: forced exit of the intermediate while loop!" << G4endl;
      #endif
      return false;
    }
 
    // kinematics
    G4double Yprojectile = 0.0, YprojectileNucleon = 0.0, Ytarget = 0.0, YtargetNucleon = 0.0;
    G4double DecayMomentum2 = sqr( common.S ) + sqr( common.M2projectile ) + sqr( common.M2target )
                              - 2.0 * ( common.S * ( common.M2projectile + common.M2target )
                                        + common.M2projectile * common.M2target );
    if ( interactionCase == 1 ) {
      common.WminusTarget = (   common.S - common.M2projectile + common.M2target 
                              + std::sqrt( DecayMomentum2 ) ) / 2.0 / common.SqrtS;
      common.WplusProjectile = common.SqrtS - common.M2target / common.WminusTarget;
      common.Pzprojectile =   common.WplusProjectile / 2.0 
                            - common.M2projectile / 2.0 / common.WplusProjectile;
      common.Eprojectile =    common.WplusProjectile / 2.0 
                            + common.M2projectile / 2.0 / common.WplusProjectile;
      Yprojectile  = 0.5 * G4Log(   ( common.Eprojectile + common.Pzprojectile )
                                  / ( common.Eprojectile - common.Pzprojectile ) );
      #ifdef debugAdjust
      G4cout << "DecayMomentum2 " << DecayMomentum2 << G4endl
             << "WminusTarget WplusProjectile " << common.WminusTarget 
             << " " << common.WplusProjectile << G4endl 
             << "Yprojectile " << Yprojectile << G4endl;
      #endif
      common.Mt2targetNucleon = sqr( common.TNucleonMass ) + common.PtNucleon.mag2();
      common.PztargetNucleon = - common.WminusTarget * common.XminusNucleon / 2.0
                               + common.Mt2targetNucleon 
                                 / ( 2.0 * common.WminusTarget * common.XminusNucleon );
      common.EtargetNucleon =   common.WminusTarget * common.XminusNucleon / 2.0
                              + common.Mt2targetNucleon
                                / ( 2.0 * common.WminusTarget * common.XminusNucleon );
      YtargetNucleon = 0.5 * G4Log(   ( common.EtargetNucleon + common.PztargetNucleon )
                                    / ( common.EtargetNucleon - common.PztargetNucleon ) );
      #ifdef debugAdjust
      G4cout << "YtN Ytr YtN-Ytr " << " " << YtargetNucleon << " " << common.YtargetNucleus 
             << " " << YtargetNucleon - common.YtargetNucleus << G4endl
             << "YtN Ypr YtN-Ypr " << " " << YtargetNucleon << " " << Yprojectile
             << " " << YtargetNucleon - Yprojectile << G4endl;
      #endif
      if ( std::abs( YtargetNucleon - common.YtargetNucleus ) > 2  ||
           Yprojectile < YtargetNucleon ) {
        OuterSuccess = false; 
        continue;
      }
    } else if ( interactionCase == 2 ) {
      common.WplusProjectile = (   common.S + common.M2projectile - common.M2target 
                                 + std::sqrt( DecayMomentum2 ) ) / 2.0 / common.SqrtS;
      common.WminusTarget = common.SqrtS - common.M2projectile / common.WplusProjectile;
      common.Pztarget = - common.WminusTarget / 2.0 + common.M2target / 2.0 / common.WminusTarget;
      common.Etarget =    common.WminusTarget / 2.0 + common.M2target / 2.0 / common.WminusTarget;
      Ytarget = 0.5 * G4Log(   ( common.Etarget + common.Pztarget )
                             / ( common.Etarget - common.Pztarget ) );
      #ifdef debugAdjust
      G4cout << "DecayMomentum2 " << DecayMomentum2 << G4endl
             << "WminusTarget WplusProjectile " << common.WminusTarget 
             << " " << common.WplusProjectile << G4endl 
             << "Ytarget " << Ytarget << G4endl;
      #endif
      common.Mt2projectileNucleon = sqr( common.TNucleonMass ) + common.PtNucleon.mag2();
      common.PzprojectileNucleon =   common.WplusProjectile * common.XplusNucleon / 2.0
                                   - common.Mt2projectileNucleon
                                     / ( 2.0 * common.WplusProjectile * common.XplusNucleon );
      common.EprojectileNucleon =    common.WplusProjectile * common.XplusNucleon / 2.0 
                                   + common.Mt2projectileNucleon
                                     / ( 2.0 * common.WplusProjectile * common.XplusNucleon );
      YprojectileNucleon = 0.5 * G4Log(   ( common.EprojectileNucleon + common.PzprojectileNucleon )
                                        / ( common.EprojectileNucleon - common.PzprojectileNucleon) );
      #ifdef debugAdjust
      G4cout << "YpN Ypr YpN-Ypr " << " " << YprojectileNucleon << " " << common.YprojectileNucleus
             << " " << YprojectileNucleon - common.YprojectileNucleus << G4endl
             << "YpN Ytr YpN-Ytr " << " " << YprojectileNucleon << " " << Ytarget
             << " " << YprojectileNucleon - Ytarget << G4endl;
      #endif
      if ( std::abs( YprojectileNucleon - common.YprojectileNucleus ) > 2  ||
           Ytarget > YprojectileNucleon ) {
        OuterSuccess = false; 
        continue;
      }
    } else if ( interactionCase == 3 ) {
      common.WplusProjectile = (   common.S + common.M2projectile - common.M2target 
                                 + std::sqrt( DecayMomentum2 ) ) / 2.0 / common.SqrtS;
      common.WminusTarget = common.SqrtS - common.M2projectile / common.WplusProjectile;
      common.Mt2projectileNucleon = sqr( common.PNucleonMass ) + common.PtNucleonP.mag2();
      common.PzprojectileNucleon =   common.WplusProjectile * common.XplusNucleon / 2.0
                                   - common.Mt2projectileNucleon
                                     / ( 2.0 * common.WplusProjectile * common.XplusNucleon );
      common.EprojectileNucleon =    common.WplusProjectile * common.XplusNucleon / 2.0
                                   + common.Mt2projectileNucleon
                                     / ( 2.0 * common.WplusProjectile * common.XplusNucleon );
      YprojectileNucleon = 0.5 * G4Log(   ( common.EprojectileNucleon + common.PzprojectileNucleon )
                                        / ( common.EprojectileNucleon - common.PzprojectileNucleon ) );
      common.Mt2targetNucleon = sqr( common.TNucleonMass ) + common.PtNucleonT.mag2();
      common.PztargetNucleon = - common.WminusTarget * common.XminusNucleon / 2.0
                               + common.Mt2targetNucleon
                                 / ( 2.0 * common.WminusTarget * common.XminusNucleon );
      common.EtargetNucleon =    common.WminusTarget * common.XminusNucleon / 2.0
                               + common.Mt2targetNucleon
                                 / ( 2.0 * common.WminusTarget * common.XminusNucleon );
      YtargetNucleon = 0.5 * G4Log(   ( common.EtargetNucleon + common.PztargetNucleon )
                                    / ( common.EtargetNucleon - common.PztargetNucleon ) ); 
      if ( std::abs( YtargetNucleon - common.YtargetNucleus ) > 2          ||
           std::abs( YprojectileNucleon - common.YprojectileNucleus ) > 2  ||
           YprojectileNucleon < YtargetNucleon ) {
        OuterSuccess = false;
        continue;
      }
    }  // End-if on interactionCase
 
  } while ( ( ! OuterSuccess ) &&                // Outmost do while loop
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    #ifdef debugAdjust
    G4cout << "BAD situation: forced exit of the while loop!" << G4endl;
    #endif
    return false;
  }
 
  return true;
}

References common(), condition(), G4cout, G4endl, G4Log(), GaussianPt(), G4FTFParameters::GetDofNuclearDestruction(), G4FTFParameters::GetMaxPt2ofNuclearDestruction(), G4FTFParameters::GetPt2ofNuclearDestruction(), ProjectileResidualMassNumber, sqr(), TargetResidualMassNumber, theParameters, and CLHEP::Hep3Vector::x().

Referenced by AdjustNucleons().

◆ ApplyYourself()

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

virtualinherited

Reimplemented in G4WilsonAbrasionModel, G4EMDissociation, G4VLongitudinalStringDecay, G4FissLib, G4LENDorBERTModel, G4LENDCapture, G4LENDCombinedModel, G4LENDElastic, G4LENDFission, G4LENDGammaModel, G4LENDInelastic, G4LENDModel, G4ElectroVDNuclearModel, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, G4ParticleHPThermalScattering, G4GeneratorPrecompoundInterface, G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4LFission, G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4MuonVDNuclearModel, G4NeutrinoElectronCcModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4QMDReaction, G4EmCaptureCascade, G4MuMinusCapturePrecompound, G4MuonMinusBoundDecay, G4NeutronRadCapture, G4LowEGammaNuclearModel, G4ChargeExchange, G4HadronElastic, G4LEHadronProtonElastic, G4LEnp, G4LEpp, G4NeutrinoNucleusModel, G4BinaryCascade, G4BinaryLightIonReaction, G4CascadeInterface, G4INCLXXInterface, G4LMsdGenerator, G4PreCompoundModel, G4LowEIonFragmentation, G4TheoFSGenerator, and G4AblaInterface.

Definition at line 63 of file G4HadronicInteraction.cc.

{
  return nullptr;
}

Referenced by G4LENDorBERTModel::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4MuonMinusAtomicCapture::AtRestDoIt(), G4MuonicAtomDecay::DecayIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

◆ Block()

void G4HadronicInteraction::Block ( )

inlineprotectedinherited

Definition at line 170 of file G4HadronicInteraction.hh.

170{ isBlocked = true; }

G4HadronicInteraction::isBlocked

G4bool isBlocked

Definition: G4HadronicInteraction.hh:188

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::ActivateFor(), G4HadronicInteraction::DeActivateFor(), G4HadronicInteraction::SetMaxEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ BuildPhysicsTable()

void G4HadronicInteraction::BuildPhysicsTable ( const G4ParticleDefinition & )

virtualinherited

Reimplemented in G4LENDorBERTModel, G4LENDCombinedModel, G4LENDGammaModel, G4LENDModel, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, G4ParticleHPThermalScattering, G4AblaInterface, and G4PreCompoundModel.

Definition at line 56 of file G4HadronicInteraction.cc.

57{}

◆ BuildStrings()

void G4FTFModel::BuildStrings ( G4ExcitedStringVector * strings )

private

Definition at line 1975 of file G4FTFModel.cc.

                                                              {
  // Loop over all collisions; find all primaries, and all targets 
  // (targets may be duplicate in the List (to unique G4VSplitableHadrons) ).
 
  G4ExcitedString* FirstString( 0 );     // If there will be a kink,
  G4ExcitedString* SecondString( 0 );    // two strings will be produced.
 
  if ( ! GetProjectileNucleus() ) {
 
    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 ( interaction.GetStatus() ) {
        if ( primaries.end() == std::find( primaries.begin(), primaries.end(), 
                                           interaction.GetProjectile() ) ) {
          primaries.push_back( interaction.GetProjectile() );
        }
      }
    }
 
    #ifdef debugBuildString
    G4cout << "G4FTFModel::BuildStrings()" << G4endl
           << "Number of projectile strings " << primaries.size() << G4endl;
    #endif
 
    for ( unsigned int ahadron = 0; ahadron < primaries.size(); ahadron++ ) {
      G4bool isProjectile( true );
      //G4cout << "primaries[ ahadron ] " << primaries[ ahadron ] << G4endl;
      //if ( primaries[ ahadron ]->GetStatus() <= 1 ) isProjectile = true;
      FirstString = 0; SecondString = 0;
      if ( primaries[ahadron]->GetStatus() == 0 ) {
       theExcitation->CreateStrings( primaries[ ahadron ], isProjectile, 
                                     FirstString, SecondString, theParameters );
       NumberOfProjectileSpectatorNucleons--;
      } else if ( primaries[ahadron]->GetStatus() == 1  
               && primaries[ahadron]->GetSoftCollisionCount() != 0 ) {
       theExcitation->CreateStrings( primaries[ ahadron ], isProjectile, 
                                     FirstString, SecondString, theParameters );
       NumberOfProjectileSpectatorNucleons--;
      } else if ( primaries[ahadron]->GetStatus() == 1  
               && primaries[ahadron]->GetSoftCollisionCount() == 0 ) {
       G4LorentzVector ParticleMomentum=primaries[ahadron]->Get4Momentum();
       G4KineticTrack* aTrack = new G4KineticTrack( primaries[ahadron]->GetDefinition(),
                                                    primaries[ahadron]->GetTimeOfCreation(),
                                                    primaries[ahadron]->GetPosition(),
                                                    ParticleMomentum );
       FirstString = new G4ExcitedString( aTrack );
      } else if (primaries[ahadron]->GetStatus() == 2) {
       G4LorentzVector ParticleMomentum=primaries[ahadron]->Get4Momentum();
       G4KineticTrack* aTrack = new G4KineticTrack( primaries[ahadron]->GetDefinition(),
                                                    primaries[ahadron]->GetTimeOfCreation(),
                                                    primaries[ahadron]->GetPosition(),
                                                    ParticleMomentum );
       FirstString = new G4ExcitedString( aTrack );
       NumberOfProjectileSpectatorNucleons--;
      } else {
        G4cout << "Something wrong in FTF Model Build String" << G4endl;
      }
 
      if ( FirstString  != 0 ) strings->push_back( FirstString );
      if ( SecondString != 0 ) strings->push_back( SecondString );
 
      #ifdef debugBuildString
      G4cout << "FirstString & SecondString? " << FirstString << " " << SecondString << G4endl;
      if ( FirstString->IsExcited() ) {
        G4cout << "Quarks on the FirstString ends " << FirstString->GetRightParton()->GetPDGcode()
               << " " << FirstString->GetLeftParton()->GetPDGcode() << G4endl;
      } else {
        G4cout << "Kinetic track is stored" << G4endl;
      }
      #endif
 
    }
 
    #ifdef debugBuildString
    if ( FirstString->IsExcited() ) {
      G4cout << "Check 1 string " << strings->operator[](0)->GetRightParton()->GetPDGcode() 
             << " " << strings->operator[](0)->GetLeftParton()->GetPDGcode() << G4endl << G4endl;
    }
    #endif
 
    std::for_each( primaries.begin(), primaries.end(), DeleteVSplitableHadron() );
    primaries.clear();
 
  } else {  // Projectile is a nucleus
 
    #ifdef debugBuildString
    G4cout << "Building of projectile-like strings" << G4endl;
    #endif
 
    G4bool isProjectile = true;
    for ( G4int ahadron = 0; ahadron < NumberOfInvolvedNucleonsOfProjectile; ahadron++ ) {
 
      #ifdef debugBuildString
      G4cout << "Nucleon #, status, intCount " << ahadron << " "
             << TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron()->GetStatus() 
             << " " << TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron()
                       ->GetSoftCollisionCount()<<G4endl;
      #endif
 
      G4VSplitableHadron* aProjectile = 
          TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron();
 
      #ifdef debugBuildString
      G4cout << G4endl << "ahadron aProjectile Status " << ahadron << " " << aProjectile
             << " " << aProjectile->GetStatus() << G4endl;
      #endif
 
      FirstString = 0; SecondString = 0;
      if ( aProjectile->GetStatus() == 0 ) {  // A nucleon took part in non-diffractive interaction
 
        #ifdef debugBuildString
        G4cout << "Case1 aProjectile->GetStatus() == 0 " << G4endl;
        #endif
 
        theExcitation->CreateStrings( 
                           TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron(),
                           isProjectile, FirstString, SecondString, theParameters );
        NumberOfProjectileSpectatorNucleons--;
      } else if ( aProjectile->GetStatus() == 1 && aProjectile->GetSoftCollisionCount() != 0 ) { 
        // Nucleon took part in diffractive interaction
 
        #ifdef debugBuildString
        G4cout << "Case2 aProjectile->GetStatus() !=0 St==1 SoftCol!=0" << G4endl;
        #endif
 
        theExcitation->CreateStrings( 
                           TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron(),
                           isProjectile, FirstString, SecondString, theParameters );
        NumberOfProjectileSpectatorNucleons--;
      } else if ( aProjectile->GetStatus() == 1  &&  aProjectile->GetSoftCollisionCount() == 0  &&
                  HighEnergyInter ) {
        // Nucleon was considered as a paricipant of an interaction,
        // but the interaction was skipped due to annihilation.
        // It is now considered as an involved nucleon at high energies.
 
        #ifdef debugBuildString
        G4cout << "Case3 aProjectile->GetStatus() !=0 St==1 SoftCol==0" << G4endl;
        #endif
 
        G4LorentzVector ParticleMomentum = aProjectile->Get4Momentum();
        G4KineticTrack* aTrack = new G4KineticTrack( aProjectile->GetDefinition(),
                                                     aProjectile->GetTimeOfCreation(),
                                                     aProjectile->GetPosition(),
                                                     ParticleMomentum );
        FirstString = new G4ExcitedString( aTrack );
 
        #ifdef debugBuildString
        G4cout << " Strings are built for nucleon marked for an interaction, but"
               << " the interaction was skipped." << G4endl;
        #endif
 
      } else if ( aProjectile->GetStatus() == 2  ||  aProjectile->GetStatus() == 3 ) {
        // Nucleon which was involved in the Reggeon cascading
 
        #ifdef debugBuildString
        G4cout << "Case4 aProjectile->GetStatus() !=0 St==2 " << G4endl;
        #endif
 
        G4LorentzVector ParticleMomentum = aProjectile->Get4Momentum();
        G4KineticTrack* aTrack = new G4KineticTrack( aProjectile->GetDefinition(),
                                                     aProjectile->GetTimeOfCreation(),
                                                     aProjectile->GetPosition(),
                                                     ParticleMomentum );
        FirstString = new G4ExcitedString( aTrack );
 
        #ifdef debugBuildString
        G4cout << " Strings are build for involved nucleon." << G4endl;
        #endif
 
        if ( aProjectile->GetStatus() == 2 ) NumberOfProjectileSpectatorNucleons--;
      } else {
 
        #ifdef debugBuildString
        G4cout << "Case5 " << G4endl;
        #endif
 
        //TheInvolvedNucleonsOfProjectile[ ahadron ]->Hit( 0 );
        //G4cout << TheInvolvedNucleonsOfProjectile[ ahadron ]->GetSplitableHadron() << G4endl;
 
        #ifdef debugBuildString
        G4cout << " No string" << G4endl;
        #endif
 
      }
 
      if ( FirstString  != 0 ) strings->push_back( FirstString );
      if ( SecondString != 0 ) strings->push_back( SecondString );
    }
  } 
 
  #ifdef debugBuildString
  G4cout << "Building of target-like strings" << G4endl;
  #endif
 
  G4bool isProjectile = false;
  for ( G4int ahadron = 0; ahadron < NumberOfInvolvedNucleonsOfTarget; ahadron++ ) {
    G4VSplitableHadron* aNucleon = TheInvolvedNucleonsOfTarget[ ahadron ]->GetSplitableHadron();
 
    #ifdef debugBuildString
    G4cout << "Nucleon #, status, intCount " << aNucleon << " " << ahadron << " "
           << aNucleon->GetStatus() << " " << aNucleon->GetSoftCollisionCount()<<G4endl;;
    #endif
 
    FirstString = 0 ; SecondString = 0;
 
    if ( aNucleon->GetStatus() == 0 ) { // A nucleon took part in non-diffractive interaction
      theExcitation->CreateStrings( aNucleon, isProjectile, 
                                    FirstString, SecondString, theParameters );
      NumberOfTargetSpectatorNucleons--;
 
      #ifdef debugBuildString
      G4cout << " 1 case A string is build" << G4endl;
      #endif
 
    } else if ( aNucleon->GetStatus() == 1  &&  aNucleon->GetSoftCollisionCount() != 0 ) {
      // A nucleon took part in diffractive interaction
      theExcitation->CreateStrings( aNucleon, isProjectile,
                                    FirstString, SecondString, theParameters );
 
      #ifdef debugBuildString
      G4cout << " 2 case A string is build, nucleon was excited." << G4endl;
      #endif
 
      NumberOfTargetSpectatorNucleons--;
 
    } else if ( aNucleon->GetStatus() == 1  &&  aNucleon->GetSoftCollisionCount() == 0  &&
                HighEnergyInter ) {
      // A nucleon was considered as a participant but due to annihilation
      // its interactions were skipped. It will be considered as involved one
      // at high energies.
 
      G4LorentzVector ParticleMomentum = aNucleon->Get4Momentum();
      G4KineticTrack* aTrack = new G4KineticTrack( aNucleon->GetDefinition(),
                                                   aNucleon->GetTimeOfCreation(),
                                                   aNucleon->GetPosition(),
                                                   ParticleMomentum );
 
      FirstString = new G4ExcitedString( aTrack );
 
      #ifdef debugBuildString
      G4cout << "3 case A string is build" << G4endl;
      #endif
 
    } else if ( aNucleon->GetStatus() == 1  &&  aNucleon->GetSoftCollisionCount() == 0  &&
                ! HighEnergyInter ) {
      // A nucleon was considered as a participant but due to annihilation
      // its interactions were skipped. It will be returned to nucleus
      // at low energies energies.
      aNucleon->SetStatus( 5 );  // 4->5
      // ??? delete aNucleon;
 
      #ifdef debugBuildString
      G4cout << "4 case A string is not build" << G4endl;
      #endif
 
    } else if ( aNucleon->GetStatus() == 2  ||   // A nucleon took part in quark exchange
                aNucleon->GetStatus() == 3  ) {  // A nucleon was involved in Reggeon cascading
      G4LorentzVector ParticleMomentum = aNucleon->Get4Momentum();
      G4KineticTrack* aTrack = new G4KineticTrack( aNucleon->GetDefinition(),
                                                   aNucleon->GetTimeOfCreation(),
                                                   aNucleon->GetPosition(),
                                                   ParticleMomentum );
      FirstString = new G4ExcitedString( aTrack );
 
      #ifdef debugBuildString
      G4cout << "5 case A string is build" << G4endl;
      #endif
 
      if ( aNucleon->GetStatus() == 2 ) NumberOfTargetSpectatorNucleons--;
 
    } else {
 
      #ifdef debugBuildString
      G4cout << "6 case No string" << G4endl;
      #endif
 
    }
 
    if ( FirstString  != 0 ) strings->push_back( FirstString );
    if ( SecondString != 0 ) strings->push_back( SecondString );
 
  }
 
  #ifdef debugBuildString
  G4cout << G4endl << "theAdditionalString.size() " << theAdditionalString.size() 
         << G4endl << G4endl;
  #endif
 
  isProjectile = true;
  if ( theAdditionalString.size() != 0 ) {
    for ( unsigned int  ahadron = 0; ahadron < theAdditionalString.size(); ahadron++ ) {
      //if ( theAdditionalString[ ahadron ]->GetStatus() <= 1 ) isProjectile = true; 
      FirstString = 0; SecondString = 0;
      theExcitation->CreateStrings( theAdditionalString[ ahadron ], isProjectile,
                                    FirstString, SecondString, theParameters );
      if ( FirstString  != 0 ) strings->push_back( FirstString );
      if ( SecondString != 0 ) strings->push_back( SecondString );
    }
  }
 
  //for ( unsigned int ahadron = 0; ahadron < strings->size(); ahadron++ ) {
  //  G4cout << ahadron << " " << strings->operator[]( ahadron )->GetRightParton()->GetPDGcode()
  //         << " " << strings->operator[]( ahadron )->GetLeftParton()->GetPDGcode() << G4endl;
  //}
  //G4cout << "------------------------" << G4endl;
 
  return;
}

References G4DiffractiveExcitation::CreateStrings(), G4cout, G4endl, G4VSplitableHadron::Get4Momentum(), G4VSplitableHadron::GetDefinition(), G4FTFParticipants::GetInteraction(), G4ExcitedString::GetLeftParton(), G4Parton::GetPDGcode(), G4VSplitableHadron::GetPosition(), G4InteractionContent::GetProjectile(), GetProjectileNucleus(), G4ExcitedString::GetRightParton(), G4VSplitableHadron::GetSoftCollisionCount(), G4Nucleon::GetSplitableHadron(), G4VSplitableHadron::GetStatus(), G4InteractionContent::GetStatus(), G4VSplitableHadron::GetTimeOfCreation(), HighEnergyInter, G4ExcitedString::IsExcited(), G4FTFParticipants::Next(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, NumberOfProjectileSpectatorNucleons, NumberOfTargetSpectatorNucleons, G4VSplitableHadron::SetStatus(), G4FTFParticipants::StartLoop(), theAdditionalString, theExcitation, TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, theParameters, and theParticipants.

Referenced by GetStrings().

◆ CheckKinematics()

G4bool G4FTFModel::CheckKinematics	(	const G4double	sValue,
		const G4double	sqrtS,
		const G4double	projectileMass2,
		const G4double	targetMass2,
		const G4double	nucleusY,
		const G4bool	isProjectileNucleus,
		const G4int	numberOfInvolvedNucleons,
		G4Nucleon *	involvedNucleons[],
		G4double &	targetWminus,
		G4double &	projectileWplus,
		G4bool &	success
	)

private

Definition at line 2945 of file G4FTFModel.cc.

                                   {                    // input & output parameter
 
  // This method, which is called only by PutOnMassShell, checks whether the
  // kinematics is acceptable or not.
  // This method assumes that all the parameters have been initialized by the caller;
  // notice that the input boolean parameter isProjectileNucleus is meant to be true
  // only in the case of nucleus or antinucleus projectile.
  // The action of this method consists in computing targetWminus and projectileWplus
  // and setting the parameter success to false in the case that the kinematics should
  // be rejeted.
 
  G4double decayMomentum2 = sqr( sValue ) + sqr( projectileMass2 ) + sqr( targetMass2 )
                            - 2.0*( sValue*( projectileMass2 + targetMass2 ) 
                                    + projectileMass2*targetMass2 );
  targetWminus = ( sValue - projectileMass2 + targetMass2 + std::sqrt( decayMomentum2 ) )
                 / 2.0 / sqrtS;
  projectileWplus = sqrtS - targetMass2/targetWminus;
  G4double projectilePz = projectileWplus/2.0 - projectileMass2/2.0/projectileWplus;
  G4double projectileE  = projectileWplus/2.0 + projectileMass2/2.0/projectileWplus;
  G4double projectileY  = 0.5 * G4Log( (projectileE + projectilePz)/
                                       (projectileE - projectilePz) );
  G4double targetPz = -targetWminus/2.0 + targetMass2/2.0/targetWminus;
  G4double targetE  =  targetWminus/2.0 + targetMass2/2.0/targetWminus;
  G4double targetY  = 0.5 * G4Log( (targetE + targetPz)/(targetE - targetPz) );
 
  #ifdef debugPutOnMassShell
  G4cout << "decayMomentum2 " << decayMomentum2 << G4endl 
         << "\t targetWminus projectileWplus " << targetWminus << " " << projectileWplus << G4endl
         << "\t projectileY targetY " << projectileY << " " << targetY << G4endl;
  #endif
 
  for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
    G4Nucleon* aNucleon = involvedNucleons[i];
    if ( ! aNucleon ) continue;
    G4LorentzVector tmp = aNucleon->Get4Momentum();
    G4double mt2 = sqr( tmp.x() ) + sqr( tmp.y() ) +
                   sqr( aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass() );
    G4double x = tmp.z();
    G4double pz = -targetWminus*x/2.0 + mt2/(2.0*targetWminus*x);
    G4double e =   targetWminus*x/2.0 + mt2/(2.0*targetWminus*x);
    if ( isProjectileNucleus ) {
      pz = projectileWplus*x/2.0 - mt2/(2.0*projectileWplus*x);
      e =  projectileWplus*x/2.0 + mt2/(2.0*projectileWplus*x);
    }
    G4double nucleonY = 0.5 * G4Log( (e + pz)/(e - pz) ); 
 
    #ifdef debugPutOnMassShell
    G4cout << "i nY pY nY-AY AY " << i << " " << nucleonY << " " << projectileY <<G4endl;
    #endif
 
    if ( std::abs( nucleonY - nucleusY ) > 2  ||  
         ( isProjectileNucleus  &&  targetY > nucleonY )  ||
         ( ! isProjectileNucleus  &&  projectileY < nucleonY ) ) {
      success = false; 
      break;
    } 
  }
  return true;
}  

References G4cout, G4endl, G4Log(), G4Nucleon::Get4Momentum(), G4VSplitableHadron::GetDefinition(), G4ParticleDefinition::GetPDGMass(), G4Nucleon::GetSplitableHadron(), sqr(), CLHEP::HepLorentzVector::x(), CLHEP::HepLorentzVector::y(), and CLHEP::HepLorentzVector::z().

Referenced by PutOnMassShell().

◆ ComputeNucleusProperties()

G4bool G4FTFModel::ComputeNucleusProperties	(	G4V3DNucleus *	nucleus,
		G4LorentzVector &	nucleusMomentum,
		G4LorentzVector &	residualMomentum,
		G4double &	sumMasses,
		G4double &	residualExcitationEnergy,
		G4double &	residualMass,
		G4int &	residualMassNumber,
		G4int &	residualCharge
	)

private

Definition at line 2630 of file G4FTFModel.cc.

                                                  {            // input & output parameter
 
  // This method, which is called only by PutOnMassShell, computes some nucleus properties for:
  // -  either the target nucleus (which is never an antinucleus): this for any kind
  //    of hadronic interaction (hadron-nucleus, nucleus-nucleus, antinucleus-nucleus);
  // -  or the projectile nucleus or antinucleus: this only in the case of nucleus-nucleus
  //    or antinucleus-nucleus interaction.
  // This method assumes that the all the parameters have been initialized by the caller;
  // the action of this method consists in modifying all these parameters, except the
  // first one. The return value is "false" only in the case the pointer to the nucleus
  // is null.
 
  if ( ! nucleus ) return false;
 
  G4double ExcitationEnergyPerWoundedNucleon = 
    theParameters->GetExcitationEnergyPerWoundedNucleon();
 
  // Loop over the nucleons of the nucleus. 
  // The nucleons that have been involved in the interaction (either from Glauber or
  // Reggeon Cascading) will be candidate to be emitted.
  // All the remaining nucleons will be the nucleons of the candidate residual nucleus.
  // The variable sumMasses is the amount of energy corresponding to:
  //     1. transverse mass of each involved nucleon
  //     2. 20.0*MeV separation energy for each involved nucleon
  //     3. transverse mass of the residual nucleus
  // In this first evaluation of sumMasses, the excitation energy of the residual nucleus
  // (residualExcitationEnergy, estimated by adding a constant value to each involved
  // nucleon) is not taken into account.
  G4int residualNumberOfLambdas = 0;  // Projectile nucleus and its residual can be a hypernucleus
  G4Nucleon* aNucleon = 0;
  nucleus->StartLoop();
  while ( ( aNucleon = nucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
    nucleusMomentum += aNucleon->Get4Momentum();
    if ( aNucleon->AreYouHit() ) {  // Involved nucleons
      // Consider in sumMasses the nominal, i.e. on-shell, masses of the nucleons
      // (not the current masses, which could be different because the nucleons are off-shell).
      sumMasses += std::sqrt( sqr( aNucleon->GetDefinition()->GetPDGMass() ) 
                              +  aNucleon->Get4Momentum().perp2() );                     
      sumMasses += 20.0*MeV;  // Separation energy for a nucleon
 
      //residualExcitationEnergy += ExcitationEnergyPerWoundedNucleon;  // In G4 10.1
      residualExcitationEnergy += -ExcitationEnergyPerWoundedNucleon*G4Log( G4UniformRand() );
 
      residualMassNumber--;
      // The absolute value below is needed only in the case of anti-nucleus.
      residualCharge -= std::abs( G4int( aNucleon->GetDefinition()->GetPDGCharge() ) );
    } else {   // Spectator nucleons
      residualMomentum += aNucleon->Get4Momentum();
      if ( aNucleon->GetDefinition() == G4Lambda::Definition()  ||
       aNucleon->GetDefinition() == G4AntiLambda::Definition() ) {
    ++residualNumberOfLambdas;
      }
    }
  }
  #ifdef debugPutOnMassShell
  G4cout << "ExcitationEnergyPerWoundedNucleon " << ExcitationEnergyPerWoundedNucleon << G4endl
         << "\t Residual Charge, MassNumber (LambdaNumber" << residualCharge << " "
     << residualMassNumber << " (" << residualNumberOfLambdas << ") "
         << G4endl << "\t Initial Momentum " << nucleusMomentum
         << G4endl << "\t Residual Momentum   " << residualMomentum << G4endl;
  #endif
  residualMomentum.setPz( 0.0 ); 
  residualMomentum.setE( 0.0 );
  if ( residualMassNumber == 0 ) {
    residualMass = 0.0;
    residualExcitationEnergy = 0.0;
  } else {
    if ( residualNumberOfLambdas > 0 ) {
      residualMass = G4HyperNucleiProperties::GetNuclearMass( residualMassNumber, residualCharge,
                                  residualNumberOfLambdas );
    } else {
      residualMass = G4ParticleTable::GetParticleTable()->GetIonTable()->
                   GetIonMass( residualCharge, residualMassNumber );
    }
    if ( residualMassNumber == 1 ) {
      residualExcitationEnergy = 0.0;
    }
    residualMass += residualExcitationEnergy;
  }
  sumMasses += std::sqrt( sqr( residualMass ) + residualMomentum.perp2() );
  return true;
}

References G4Nucleon::AreYouHit(), G4AntiLambda::Definition(), G4Lambda::Definition(), G4cout, G4endl, G4Log(), G4UniformRand, G4Nucleon::Get4Momentum(), G4Nucleon::GetDefinition(), G4FTFParameters::GetExcitationEnergyPerWoundedNucleon(), G4ParticleTable::GetIonTable(), G4V3DNucleus::GetNextNucleon(), G4HyperNucleiProperties::GetNuclearMass(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), MeV, CLHEP::HepLorentzVector::perp2(), CLHEP::HepLorentzVector::setE(), CLHEP::HepLorentzVector::setPz(), sqr(), G4V3DNucleus::StartLoop(), and theParameters.

Referenced by PutOnMassShell().

◆ DeActivateFor() [1/2]

void G4HadronicInteraction::DeActivateFor ( const G4Element * anElement )

inherited

Definition at line 186 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedListElements.push_back(anElement);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedListElements.

◆ DeActivateFor() [2/2]

void G4HadronicInteraction::DeActivateFor ( const G4Material * aMaterial )

inherited

Definition at line 180 of file G4HadronicInteraction.cc.

{
  Block(); 
  theBlockedList.push_back(aMaterial);
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theBlockedList.

Referenced by G4HadronHElasticPhysics::ConstructProcess().

◆ EnergyAndMomentumCorrector()

G4bool G4VPartonStringModel::EnergyAndMomentumCorrector	(	G4KineticTrackVector *	Output,
		G4LorentzVector &	TotalCollisionMomentum
	)

protectedinherited

◆ ExciteParticipants()

G4bool G4FTFModel::ExciteParticipants ( )

private

Definition at line 847 of file G4FTFModel.cc.

                                      {
 
  #ifdef debugBuildString
  G4cout << "G4FTFModel::ExciteParticipants() " << G4endl;
  #endif
 
  G4bool Success( false );
  G4int MaxNumOfInelCollisions = G4int( theParameters->GetMaxNumberOfCollisions() );
  if ( MaxNumOfInelCollisions > 0 ) {  //  Plab > Pbound, normal application of FTF is possible
    G4double ProbMaxNumber = theParameters->GetMaxNumberOfCollisions() - MaxNumOfInelCollisions;
    if ( G4UniformRand() < ProbMaxNumber ) MaxNumOfInelCollisions++;
  } else { 
    // Plab < Pbound, normal application of FTF is impossible,low energy corrections applied
    MaxNumOfInelCollisions = 1;
  }
 
  #ifdef debugBuildString
  G4cout << "MaxNumOfInelCollisions per hadron/nucleon " << MaxNumOfInelCollisions << G4endl;
  #endif
 
  G4int CurrentInteraction( 0 );
  theParticipants.StartLoop();
 
  G4bool InnerSuccess( true );
  while ( theParticipants.Next() ) {  /* Loop checking, 10.08.2015, A.Ribon */
    CurrentInteraction++;
    const G4InteractionContent& collision = theParticipants.GetInteraction();
    G4VSplitableHadron* projectile = collision.GetProjectile();
    G4Nucleon* ProjectileNucleon = collision.GetProjectileNucleon();
    G4VSplitableHadron* target = collision.GetTarget();
    G4Nucleon* TargetNucleon = collision.GetTargetNucleon();
 
    #ifdef debugBuildString
    G4cout << G4endl << "Interaction # Status    " << CurrentInteraction << " " 
           << collision.GetStatus() << G4endl << "Pr* Tr* " << projectile << " "
           << target << G4endl << "projectile->GetStatus target->GetStatus "
           << projectile->GetStatus() << " " << target->GetStatus() << G4endl
           << "projectile->GetSoftC  target->GetSoftC  " << projectile->GetSoftCollisionCount()
           << " " << target->GetSoftCollisionCount() << G4endl;
    #endif
 
    if ( collision.GetStatus() ) {
      if ( G4UniformRand() < theParameters->GetProbabilityOfElasticScatt() ) { 
        // Elastic scattering
 
        #ifdef debugBuildString
        G4cout << "Elastic scattering" << G4endl;
        #endif
 
        if ( ! HighEnergyInter ) {
          G4bool Annihilation = false;
          G4bool Result = AdjustNucleons( projectile, ProjectileNucleon, target,
                                          TargetNucleon, Annihilation );
          if ( ! Result ) continue;
         } 
         InnerSuccess = theElastic->ElasticScattering( projectile, target, theParameters );
      } else if ( G4UniformRand() > theParameters->GetProbabilityOfAnnihilation() ) { 
        // Inelastic scattering
 
        #ifdef debugBuildString
        G4cout << "Inelastic interaction" << G4endl
               << "MaxNumOfInelCollisions per hadron/nucleon " << MaxNumOfInelCollisions << G4endl;
        #endif
 
        if ( ! HighEnergyInter ) {
          G4bool Annihilation = false;
          G4bool Result = AdjustNucleons( projectile, ProjectileNucleon, target,
                                          TargetNucleon, Annihilation );
          if ( ! Result ) continue;
        } 
        if ( G4UniformRand() < 
             ( 1.0 - target->GetSoftCollisionCount()     / MaxNumOfInelCollisions )  *
             ( 1.0 - projectile->GetSoftCollisionCount() / MaxNumOfInelCollisions ) ) {
          //if ( ! HighEnergyInter ) {
          //  G4bool Annihilation = false;
          //  G4bool Result = AdjustNucleons( projectile, ProjectileNucleon, target,
          //                                  TargetNucleon, Annihilation );
          //  if ( ! Result ) continue;
          //} 
          if ( theExcitation->ExciteParticipants( projectile, target, theParameters, theElastic ) ) {
            InnerSuccess = true;
            NumberOfNNcollisions++;
            #ifdef debugBuildString
            G4cout << "FTF excitation Successfull " << G4endl;
            // G4cout << "After  pro " << projectile->Get4Momentum() << " " 
            //        << projectile->Get4Momentum().mag() << G4endl
            //        << "After  tar " << target->Get4Momentum() << " "
            //        << target->Get4Momentum().mag() << G4endl;
            #endif
          } else {
            InnerSuccess = theElastic->ElasticScattering( projectile, target, theParameters );
            #ifdef debugBuildString
            G4cout << "FTF excitation Non InnerSuccess of Elastic scattering " 
                   << InnerSuccess << G4endl;
            #endif
          }
        } else {  // The inelastic interactition was rejected -> elastic scattering
          #ifdef debugBuildString
          G4cout << "Elastic scat. at rejection inelastic scattering" << G4endl;
          #endif
          //if ( ! HighEnergyInter ) {
          //  G4bool Annihilation = false;
          //  G4bool Result = AdjustNucleons( projectile, ProjectileNucleon, target,
          //                                  TargetNucleon, Annihilation );
          //  if ( ! Result) continue;
          //} 
          InnerSuccess = theElastic->ElasticScattering( projectile, target, theParameters );
        } 
      } else {  // Annihilation
 
        #ifdef debugBuildString
        G4cout << "Annihilation" << G4endl;
        #endif
 
        NumberOfNNcollisions++;
 
        // Skipping possible interactions of the annihilated nucleons 
        while ( theParticipants.Next() ) {   /* Loop checking, 10.08.2015, A.Ribon */  
          G4InteractionContent& acollision = theParticipants.GetInteraction();
          G4VSplitableHadron* NextProjectileNucleon = acollision.GetProjectile();
          G4VSplitableHadron* NextTargetNucleon = acollision.GetTarget();
          if ( projectile == NextProjectileNucleon  ||  target == NextTargetNucleon ) {
            acollision.SetStatus( 0 );
          }
        }
 
        // Return to the annihilation
        theParticipants.StartLoop(); 
        for ( G4int I = 0; I < CurrentInteraction; ++I ) theParticipants.Next();
 
        // At last, annihilation
        if ( ! HighEnergyInter ) {
          G4bool Annihilation = true;
          G4bool Result = AdjustNucleons( projectile, ProjectileNucleon, target,
                                          TargetNucleon, Annihilation );
          if ( ! Result ) continue;
        }             
        G4VSplitableHadron* AdditionalString = 0;
        if ( theAnnihilation->Annihilate( projectile, target, AdditionalString, theParameters ) ) {
          InnerSuccess = true;
          #ifdef debugBuildString
          G4cout << "Annihilation successfull. " << "*AdditionalString " 
                 << AdditionalString << G4endl;
          //G4cout << "After  pro " << projectile->Get4Momentum() << G4endl;
          //G4cout << "After  tar " << target->Get4Momentum() << G4endl;
          #endif
 
          if ( AdditionalString != 0 ) theAdditionalString.push_back( AdditionalString );
 
          /*
          if ( target->GetStatus() == 4 ) {
            // Skipping possible interactions of the annihilated nucleons 
            while ( theParticipants.Next() ) {    
              G4InteractionContent& acollision = theParticipants.GetInteraction();
              G4VSplitableHadron* NextProjectileNucleon = acollision.GetProjectile();
              G4VSplitableHadron* NextTargetNucleon = acollision.GetTarget();
              if ( target == NextTargetNucleon ) { acollision.SetStatus( 0 ); }
            }
          }
          theParticipants.StartLoop(); 
          for ( G4int I = 0; I < CurrentInteraction; ++I ) theParticipants.Next();
          */
 
        }
      } 
    }
 
    if( InnerSuccess ) Success = true;
 
    #ifdef debugBuildString
    G4cout << "----------------------------- Final properties " << G4endl
           << "projectile->GetStatus target->GetStatus " << projectile->GetStatus() 
           << " " << target->GetStatus() << G4endl << "projectile->GetSoftC  target->GetSoftC  "
           << projectile->GetSoftCollisionCount() << " " << target->GetSoftCollisionCount()
           << G4endl << "ExciteParticipants() Success? " << Success << G4endl;
    #endif
 
  }  // end of while ( theParticipants.Next() )
 
  return Success;
}

References AdjustNucleons(), G4FTFAnnihilation::Annihilate(), G4ElasticHNScattering::ElasticScattering(), G4DiffractiveExcitation::ExciteParticipants(), G4cout, G4endl, G4UniformRand, G4FTFParticipants::GetInteraction(), G4FTFParameters::GetMaxNumberOfCollisions(), G4FTFParameters::GetProbabilityOfAnnihilation(), G4FTFParameters::GetProbabilityOfElasticScatt(), G4InteractionContent::GetProjectile(), G4InteractionContent::GetProjectileNucleon(), G4VSplitableHadron::GetSoftCollisionCount(), G4VSplitableHadron::GetStatus(), G4InteractionContent::GetStatus(), G4InteractionContent::GetTarget(), G4InteractionContent::GetTargetNucleon(), HighEnergyInter, G4FTFParticipants::Next(), NumberOfNNcollisions, G4InteractionContent::SetStatus(), G4FTFParticipants::StartLoop(), theAdditionalString, theAnnihilation, theElastic, theExcitation, theParameters, and theParticipants.

Referenced by GetStrings().

◆ FinalizeKinematics()

G4bool G4FTFModel::FinalizeKinematics	(	const G4double	w,
		const G4bool	isProjectileNucleus,
		const G4LorentzRotation &	boostFromCmsToLab,
		const G4double	residualMass,
		const G4int	residualMassNumber,
		const G4int	numberOfInvolvedNucleons,
		G4Nucleon *	involvedNucleons[],
		G4LorentzVector &	residual4Momentum
	)

private

Definition at line 3019 of file G4FTFModel.cc.

                                                     {       // output parameter
 
  // This method, which is called only by PutOnMassShell, finalizes the kinematics:
  // this method is called when we are sure that the sampling of the kinematics is
  // acceptable.
  // This method assumes that all the parameters have been initialized by the caller;
  // notice that the input boolean parameter isProjectileNucleus is meant to be true
  // only in the case of nucleus or antinucleus projectile: this information is needed
  // because the sign of pz (in the center-of-mass frame) in this case is opposite
  // with respect to the case of a normal hadron projectile.
  // The action of this method consists in modifying the momenta of the nucleons
  // (in the lab frame) and computing the residual 4-momentum (in the center-of-mass
  // frame).
 
  G4ThreeVector residual3Momentum( 0.0, 0.0, 1.0 );
 
  for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
    G4Nucleon* aNucleon = involvedNucleons[i];
    if ( ! aNucleon ) continue;
    G4LorentzVector tmp = aNucleon->Get4Momentum();
    residual3Momentum -= tmp.vect();
    G4double mt2 = sqr( tmp.x() ) + sqr( tmp.y() ) +
                   sqr( aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass() );
    G4double x = tmp.z();
    G4double pz = -w * x / 2.0  +  mt2 / ( 2.0 * w * x );
    G4double e  =  w * x / 2.0  +  mt2 / ( 2.0 * w * x );
    // Reverse the sign of pz in the case of nucleus or antinucleus projectile
    if ( isProjectileNucleus ) pz *= -1.0;
    tmp.setPz( pz ); 
    tmp.setE( e );
    tmp.transform( boostFromCmsToLab );
    aNucleon->SetMomentum( tmp );
    G4VSplitableHadron* splitableHadron = aNucleon->GetSplitableHadron();
    splitableHadron->Set4Momentum( tmp );
  }
 
  G4double residualMt2 = sqr( residualMass ) + sqr( residual3Momentum.x() )
                       + sqr( residual3Momentum.y() );
 
  #ifdef debugPutOnMassShell
  G4cout << "w residual3Momentum.z() " << w << " " << residual3Momentum.z() << G4endl;
  #endif
 
  G4double residualPz = 0.0;
  G4double residualE  = 0.0;
  if ( residualMassNumber != 0 ) {
    residualPz = -w * residual3Momentum.z() / 2.0 + 
                  residualMt2 / ( 2.0 * w * residual3Momentum.z() );
    residualE  =  w * residual3Momentum.z() / 2.0 + 
                  residualMt2 / ( 2.0 * w * residual3Momentum.z() );
    // Reverse the sign of residualPz in the case of nucleus or antinucleus projectile
    if ( isProjectileNucleus ) residualPz *= -1.0;
  }
 
  residual4Momentum.setPx( residual3Momentum.x() );
  residual4Momentum.setPy( residual3Momentum.y() );
  residual4Momentum.setPz( residualPz ); 
  residual4Momentum.setE( residualE );
 
  return true;
}

Referenced by PutOnMassShell().

◆ GaussianPt()

G4ThreeVector G4FTFModel::GaussianPt	(	G4double	AveragePt2,
		G4double	maxPtSquare
	)		const

private

Definition at line 2609 of file G4FTFModel.cc.

                                                                                      {
 
  G4double Pt2( 0.0 ), Pt( 0.0 );
 
  if (AveragePt2 > 0.0) {
    const G4double ymax = maxPtSquare/AveragePt2;
    if ( ymax < 200. ) {
      Pt2 = -AveragePt2 * G4Log( 1.0 + G4UniformRand() * ( G4Exp( -ymax ) -1.0 ) );
    } else {
      Pt2 = -AveragePt2 * G4Log( 1.0 - G4UniformRand() ); 
    }
    Pt = std::sqrt( Pt2 );
  }
 
  G4double phi = G4UniformRand() * twopi;
 
  return G4ThreeVector( Pt*std::cos(phi), Pt*std::sin(phi), 0.0 );    
}

References G4Exp(), G4Log(), G4UniformRand, and twopi.

Referenced by AdjustNucleonsAlgorithm_Sampling(), and SamplingNucleonKinematics().

◆ GenerateDeltaIsobar()

G4bool G4FTFModel::GenerateDeltaIsobar	(	const G4double	sqrtS,
		const G4int	numberOfInvolvedNucleons,
		G4Nucleon *	involvedNucleons[],
		G4double &	sumMasses
	)

private

Definition at line 2724 of file G4FTFModel.cc.

                                           {                // input & output parameter
 
  // This method, which is called only by PutOnMassShell, check whether is possible to
  // re-interpret some of the involved nucleons as delta-isobars:
  // - either by replacing a proton (2212) with a Delta+ (2214),
  // - or by replacing a neutron (2112) with a Delta0 (2114).
  // The on-shell mass of these delta-isobars is ~1232 MeV, so  ~292-294 MeV  heavier than
  // the corresponding nucleon on-shell mass. However  400.0*MeV  is considered to estimate
  // the max number of deltas compatible with the available energy.
  // The delta-isobars are considered with the same transverse momentum as their
  // corresponding nucleons.
  // This method assumes that all the parameters have been initialized by the caller;
  // the action of this method consists in modifying (eventually) involveNucleons and
  // sumMasses. The return value is "false" only in the case that the input parameters
  // have unphysical values.
 
  if ( sqrtS < 0.0  ||  numberOfInvolvedNucleons <= 0  ||  sumMasses < 0.0 ) return false;
 
  const G4double probDeltaIsobar = 0.05;
 
  G4int maxNumberOfDeltas = G4int( (sqrtS - sumMasses)/(400.0*MeV) );
  G4int numberOfDeltas = 0;
 
  for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
 
    if ( G4UniformRand() < probDeltaIsobar  &&  numberOfDeltas < maxNumberOfDeltas ) {
      numberOfDeltas++;
      if ( ! involvedNucleons[i] ) continue;
      // Skip any eventual lambda (that can be present in a projectile hypernucleus)
      if ( involvedNucleons[i]->GetDefinition() == G4Lambda::Definition()  ||
       involvedNucleons[i]->GetDefinition() == G4AntiLambda::Definition() ) continue;
      G4VSplitableHadron* splitableHadron = involvedNucleons[i]->GetSplitableHadron();
      G4double massNuc = std::sqrt( sqr( splitableHadron->GetDefinition()->GetPDGMass() )
                                    + splitableHadron->Get4Momentum().perp2() );
      // The absolute value below is needed in the case of an antinucleus. 
      G4int pdgCode = std::abs( splitableHadron->GetDefinition()->GetPDGEncoding() );
      const G4ParticleDefinition* old_def = splitableHadron->GetDefinition();
      G4int newPdgCode = pdgCode/10; newPdgCode = newPdgCode*10 + 4; // Delta
      if ( splitableHadron->GetDefinition()->GetPDGEncoding() < 0 ) newPdgCode *= -1;
      const G4ParticleDefinition* ptr = 
        G4ParticleTable::GetParticleTable()->FindParticle( newPdgCode );
      splitableHadron->SetDefinition( ptr );
      G4double massDelta = std::sqrt( sqr( splitableHadron->GetDefinition()->GetPDGMass() )
                                      + splitableHadron->Get4Momentum().perp2() );
      //G4cout << i << " " << sqrtS/GeV << " " << sumMasses/GeV << " " << massDelta/GeV
      //       << " " << massNuc << G4endl;
      if ( sqrtS < sumMasses + massDelta - massNuc ) {  // Change cannot be accepted!
        splitableHadron->SetDefinition( old_def );
        break;
      } else {  // Change is accepted
        sumMasses += ( massDelta - massNuc );
      }
    } 
  }
 
  return true;
}

References G4AntiLambda::Definition(), G4Lambda::Definition(), G4ParticleTable::FindParticle(), G4UniformRand, G4VSplitableHadron::Get4Momentum(), G4VSplitableHadron::GetDefinition(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4Nucleon::GetSplitableHadron(), MeV, CLHEP::HepLorentzVector::perp2(), G4VSplitableHadron::SetDefinition(), and sqr().

Referenced by PutOnMassShell().

◆ GetBmax()

G4double G4FTFModel::GetBmax ( ) const

inline

Definition at line 248 of file G4FTFModel.hh.

                                          {
  return Bmax;
}

References Bmax.

Referenced by Init().

◆ GetBmin()

G4double G4FTFModel::GetBmin ( ) const

inline

Definition at line 244 of file G4FTFModel.hh.

                                          {
  return Bmin;
}

References Bmin.

Referenced by Init().

◆ GetEnergyMomentumCheckLevels()

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

virtualinherited

Reimplemented in G4TheoFSGenerator.

Definition at line 217 of file G4HadronicInteraction.cc.

{
  return epCheckLevels;
}

References G4HadronicInteraction::epCheckLevels.

Referenced by G4HadronicProcess::CheckEnergyMomentumConservation(), and G4TheoFSGenerator::GetEnergyMomentumCheckLevels().

◆ GetFatalEnergyCheckLevels()

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

virtualinherited

Reimplemented in G4FissLib, G4LFission, G4LENDFission, G4ParticleHPCapture, G4ParticleHPElastic, G4ParticleHPFission, G4ParticleHPInelastic, and G4ParticleHPThermalScattering.

Definition at line 210 of file G4HadronicInteraction.cc.

{
  // default level of Check
  return std::pair<G4double, G4double>(2.*perCent, 1. * GeV);
}

References GeV, and perCent.

Referenced by G4HadronicProcess::CheckResult().

◆ GetImpactParameter()

G4double G4FTFModel::GetImpactParameter ( ) const

inline

Definition at line 228 of file G4FTFModel.hh.

                                                     {
  return Bimpact;
}

References Bimpact.

◆ GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const

inlineinherited

Definition at line 96 of file G4HadronicInteraction.hh.

97 { return theMaxEnergy; }

G4HadronicInteraction::theMaxEnergy

G4double theMaxEnergy

Definition: G4HadronicInteraction.hh:186

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4IonPhysics::ConstructProcess(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronElastic::G4HadronElastic(), G4hhElastic::G4hhElastic(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

◆ GetMaxEnergy() [2/2]

G4double G4HadronicInteraction::GetMaxEnergy	(	const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

inherited

Definition at line 131 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMaxEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return 0.0; }
  if(!theMaxEnergyListElements.empty()) {
    for(auto const& elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second )
    { return elmlist.first; }
    }
  }
  if(!theMaxEnergyList.empty()) {
    for(auto const& matlist : theMaxEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMaxEnergy;
}

References G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMaxEnergy, G4HadronicInteraction::theMaxEnergyList, and G4HadronicInteraction::theMaxEnergyListElements.

◆ GetMinEnergy() [1/2]

G4double G4HadronicInteraction::GetMinEnergy ( ) const

inlineinherited

Definition at line 83 of file G4HadronicInteraction.hh.

84 { return theMinEnergy; }

G4HadronicInteraction::theMinEnergy

G4double theMinEnergy

Definition: G4HadronicInteraction.hh:185

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4EnergyRangeManager::GetHadronicInteraction(), and G4HadronicProcessStore::Print().

◆ GetMinEnergy() [2/2]

G4double G4HadronicInteraction::GetMinEnergy	(	const G4Material *	aMaterial,
		const G4Element *	anElement
	)		const

inherited

Definition at line 81 of file G4HadronicInteraction.cc.

{
  if(!IsBlocked()) { return theMinEnergy; } 
  if( IsBlocked(aMaterial) || IsBlocked(anElement) ) { return DBL_MAX; }
  if(!theMinEnergyListElements.empty()) {
    for(auto const& elmlist : theMinEnergyListElements) {
    if( anElement == elmlist.second )
      { return elmlist.first; }
    }
  }
  if(!theMinEnergyList.empty()) {
    for(auto const & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second )
    { return matlist.first; }
    }
  }
  return theMinEnergy;
}

References DBL_MAX, G4HadronicInteraction::IsBlocked(), G4HadronicInteraction::theMinEnergy, G4HadronicInteraction::theMinEnergyList, and G4HadronicInteraction::theMinEnergyListElements.

◆ GetModelName()

const G4String & G4HadronicInteraction::GetModelName ( ) const

inlineinherited

Definition at line 115 of file G4HadronicInteraction.hh.

116 { return theModelName; }

G4HadronicInteraction::theModelName

G4String theModelName

Definition: G4HadronicInteraction.hh:196

References G4HadronicInteraction::theModelName.

Referenced by G4MuMinusCapturePrecompound::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4VHadronPhysics::BuildModel(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4ChargeExchangePhysics::ConstructProcess(), G4MuonicAtomDecay::DecayIt(), G4LENDModel::DumpLENDTargetInfo(), G4AblaInterface::G4AblaInterface(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4ExcitedStringDecay::G4ExcitedStringDecay(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LENDorBERTModel::G4LENDorBERTModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4LowEIonFragmentation::G4LowEIonFragmentation(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4INCLXXInterface::GetDeExcitationModelName(), G4EnergyRangeManager::GetHadronicInteraction(), G4VHighEnergyGenerator::GetProjectileNucleus(), G4NeutronRadCapture::InitialiseModel(), G4BinaryCascade::ModelDescription(), G4LMsdGenerator::ModelDescription(), G4VPartonStringModel::ModelDescription(), G4TheoFSGenerator::ModelDescription(), G4VHadronPhysics::NewModel(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4HadronicProcessStore::PrintModelHtml(), G4BinaryCascade::PropagateModelDescription(), G4HadronicProcessStore::RegisterInteraction(), and G4LENDModel::returnUnchanged().

◆ GetNumberOfNNcollisions()

G4int G4FTFModel::GetNumberOfNNcollisions ( ) const

inline

Definition at line 260 of file G4FTFModel.hh.

                                                       {
  return NumberOfNNcollisions;
}

References NumberOfNNcollisions.

◆ GetNumberOfProjectileSpectatorNucleons()

G4int G4FTFModel::GetNumberOfProjectileSpectatorNucleons ( ) const

inline

Definition at line 252 of file G4FTFModel.hh.

                                                                      {
  return NumberOfProjectileSpectatorNucleons;
}

References NumberOfProjectileSpectatorNucleons.

◆ GetNumberOfTargetSpectatorNucleons()

G4int G4FTFModel::GetNumberOfTargetSpectatorNucleons ( ) const

inline

Definition at line 256 of file G4FTFModel.hh.

                                                                  {
  return NumberOfTargetSpectatorNucleons;
}

References NumberOfTargetSpectatorNucleons.

◆ GetProjectileNucleus()

G4V3DNucleus * G4FTFModel::GetProjectileNucleus ( ) const

inlineoverridevirtual

Reimplemented from G4VHighEnergyGenerator.

Definition at line 220 of file G4FTFModel.hh.

                                                            {
  return theParticipants.GetProjectileNucleus();
}

References G4VParticipants::GetProjectileNucleus(), and theParticipants.

Referenced by AdjustNucleons(), BuildStrings(), GetResiduals(), GetStrings(), PutOnMassShell(), ReggeonCascade(), and StoreInvolvedNucleon().

◆ GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const

inlineinherited

Definition at line 141 of file G4HadronicInteraction.hh.

142 { return recoilEnergyThreshold;}

G4HadronicInteraction::recoilEnergyThreshold

G4double recoilEnergyThreshold

Definition: G4HadronicInteraction.hh:194

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4ChargeExchange::ApplyYourself(), and G4HadronElastic::ApplyYourself().

◆ GetResiduals()

void G4FTFModel::GetResiduals ( )

private

Definition at line 2290 of file G4FTFModel.cc.

                              {
  // This method is needed for the correct application of G4PrecompoundModelInterface
 
  #ifdef debugFTFmodel
  G4cout << "GetResiduals(): HighEnergyInter? GetProjectileNucleus()?"
         << HighEnergyInter << " " << GetProjectileNucleus() << G4endl;
  #endif
 
  if ( HighEnergyInter ) {
 
    #ifdef debugFTFmodel
    G4cout << "NumberOfInvolvedNucleonsOfTarget "<< NumberOfInvolvedNucleonsOfTarget << G4endl;
    #endif
 
    G4double DeltaExcitationE = TargetResidualExcitationEnergy / 
                                G4double( NumberOfInvolvedNucleonsOfTarget );
    G4LorentzVector DeltaPResidualNucleus = TargetResidual4Momentum /
                                            G4double( NumberOfInvolvedNucleonsOfTarget );
 
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfTarget[i];
 
      #ifdef debugFTFmodel
      G4VSplitableHadron* targetSplitable = aNucleon->GetSplitableHadron();
      G4cout << i << " Hit? " << aNucleon->AreYouHit() << " " << targetSplitable << G4endl;
      if ( targetSplitable ) G4cout << i << "Status " << targetSplitable->GetStatus() << G4endl;
      #endif
 
      G4LorentzVector tmp = -DeltaPResidualNucleus;
      aNucleon->SetMomentum( tmp );
      aNucleon->SetBindingEnergy( DeltaExcitationE );
    }
 
    if ( TargetResidualMassNumber != 0 ) {
      G4ThreeVector bstToCM = TargetResidual4Momentum.findBoostToCM();
 
      G4V3DNucleus* theTargetNucleus = GetTargetNucleus();
      G4LorentzVector residualMomentum( 0.0, 0.0, 0.0, 0.0 );
      G4Nucleon* aNucleon = 0;
      theTargetNucleus->StartLoop();
      while ( ( aNucleon = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( ! aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum(); tmp.boost( bstToCM );
          aNucleon->SetMomentum( tmp );
          residualMomentum += tmp;
        }
      }
 
      residualMomentum /= TargetResidualMassNumber;
 
      G4double Mass = TargetResidual4Momentum.mag();
      G4double SumMasses = 0.0;
  
      aNucleon = 0;
      theTargetNucleus->StartLoop();
      while ( ( aNucleon = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( ! aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum() - residualMomentum;
          G4double E = std::sqrt( tmp.vect().mag2() +
                                  sqr( aNucleon->GetDefinition()->GetPDGMass() - aNucleon->GetBindingEnergy() ) );
          tmp.setE( E );  aNucleon->SetMomentum( tmp );
          SumMasses += E;
        }
      }
 
      G4double Chigh = Mass / SumMasses; G4double Clow = 0.0; G4double C;
      const G4int maxNumberOfLoops = 1000;
      G4int loopCounter = 0;
      do {
        C = ( Chigh + Clow ) / 2.0;
        SumMasses = 0.0;
        aNucleon = 0;
        theTargetNucleus->StartLoop();
        while ( ( aNucleon = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
          if ( ! aNucleon->AreYouHit() ) { 
            G4LorentzVector tmp = aNucleon->Get4Momentum();
            G4double E = std::sqrt( tmp.vect().mag2()*sqr(C) +
                                    sqr( aNucleon->GetDefinition()->GetPDGMass() - aNucleon->GetBindingEnergy() ) );
            SumMasses += E;
          }
        }
 
        if ( SumMasses > Mass ) Chigh = C;
        else                    Clow  = C;
 
      } while ( Chigh - Clow > 0.01  &&
                ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
      if ( loopCounter >= maxNumberOfLoops ) {
        #ifdef debugFTFmodel
        G4cout << "BAD situation: forced exit of the first while loop in G4FTFModel::GetResidual" << G4endl
               << "\t return immediately from the method!" << G4endl;
        #endif
        return;
      }
 
      aNucleon = 0;
      theTargetNucleus->StartLoop();
      while ( ( aNucleon = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( !aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum()*C;
          G4double E = std::sqrt( tmp.vect().mag2()+
                                  sqr( aNucleon->GetDefinition()->GetPDGMass()-aNucleon->GetBindingEnergy() ) );
          tmp.setE( E ); tmp.boost( -bstToCM );  
          aNucleon->SetMomentum( tmp );     
        }
      }
    }
 
    if ( ! GetProjectileNucleus() ) return;  // The projectile is a hadron
 
    #ifdef debugFTFmodel
    G4cout << "NumberOfInvolvedNucleonsOfProjectile " << NumberOfInvolvedNucleonsOfProjectile
           << G4endl << "ProjectileResidualExcitationEnergy ProjectileResidual4Momentum "
           << ProjectileResidualExcitationEnergy << "  " << ProjectileResidual4Momentum << G4endl;
    #endif
 
    DeltaExcitationE = ProjectileResidualExcitationEnergy /
                       G4double( NumberOfInvolvedNucleonsOfProjectile );
    DeltaPResidualNucleus = ProjectileResidual4Momentum /
                            G4double( NumberOfInvolvedNucleonsOfProjectile );
 
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfProjectile[i];
 
      #ifdef debugFTFmodel
      G4VSplitableHadron* projSplitable = aNucleon->GetSplitableHadron();
      G4cout << i << " Hit? " << aNucleon->AreYouHit() << " " << projSplitable << G4endl;
      if ( projSplitable ) G4cout << i << "Status " << projSplitable->GetStatus() << G4endl;
      #endif
 
      G4LorentzVector tmp = -DeltaPResidualNucleus;
      aNucleon->SetMomentum( tmp );
      aNucleon->SetBindingEnergy( DeltaExcitationE );
    }
 
    if ( ProjectileResidualMassNumber != 0 ) {
      G4ThreeVector bstToCM = ProjectileResidual4Momentum.findBoostToCM();
 
      G4V3DNucleus* theProjectileNucleus = GetProjectileNucleus();
      G4LorentzVector residualMomentum( 0.0, 0.0, 0.0, 0.0);
      G4Nucleon* aNucleon = 0;
      theProjectileNucleus->StartLoop();
      while ( ( aNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( ! aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum(); tmp.boost( bstToCM );
          aNucleon->SetMomentum( tmp );
          residualMomentum += tmp;
        }
      }
 
      residualMomentum /= ProjectileResidualMassNumber;
 
      G4double Mass = ProjectileResidual4Momentum.mag();
      G4double SumMasses= 0.0;
  
      aNucleon = 0;
      theProjectileNucleus->StartLoop();
      while ( ( aNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( ! aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum() - residualMomentum;
          G4double E=std::sqrt( tmp.vect().mag2() +
                                sqr(aNucleon->GetDefinition()->GetPDGMass()-aNucleon->GetBindingEnergy() ) );
          tmp.setE( E );  aNucleon->SetMomentum( tmp );
          SumMasses += E;
        }
      }
 
      G4double Chigh = Mass / SumMasses; G4double Clow = 0.0; G4double C;
      const G4int maxNumberOfLoops = 1000;
      G4int loopCounter = 0;
      do {
        C = ( Chigh + Clow ) / 2.0;
 
        SumMasses = 0.0;
        aNucleon = 0;
        theProjectileNucleus->StartLoop();
        while ( ( aNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
          if ( ! aNucleon->AreYouHit() ) { 
            G4LorentzVector tmp = aNucleon->Get4Momentum();
            G4double E = std::sqrt( tmp.vect().mag2()*sqr(C) +
                                    sqr( aNucleon->GetDefinition()->GetPDGMass() - aNucleon->GetBindingEnergy() ) );
            SumMasses += E;
          }
        }
 
        if ( SumMasses > Mass) Chigh = C;
        else                   Clow  = C;
 
      } while ( Chigh - Clow > 0.01  &&
                ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
      if ( loopCounter >= maxNumberOfLoops ) {
        #ifdef debugFTFmodel
        G4cout << "BAD situation: forced exit of the second while loop in G4FTFModel::GetResidual" << G4endl
               << "\t return immediately from the method!" << G4endl;
        #endif
        return;
      }
 
      aNucleon = 0;
      theProjectileNucleus->StartLoop();
      while ( ( aNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( ! aNucleon->AreYouHit() ) { 
          G4LorentzVector tmp = aNucleon->Get4Momentum()*C;
          G4double E = std::sqrt( tmp.vect().mag2() +
                                  sqr( aNucleon->GetDefinition()->GetPDGMass() - aNucleon->GetBindingEnergy() ) );
          tmp.setE( E ); tmp.boost( -bstToCM );  
          aNucleon->SetMomentum( tmp ); 
        }
      }
    }   // End of if ( ProjectileResidualMassNumber != 0 )
  
    #ifdef debugFTFmodel
    G4cout << "End projectile" << G4endl;
    #endif
   
  } else {  // Related to the condition: if ( HighEnergyInter )
 
    #ifdef debugFTFmodel
    G4cout << "Low energy interaction: Target nucleus --------------" << G4endl
           << "Tr ResidualMassNumber Tr ResidualCharge Tr ResidualExcitationEnergy  "
           << TargetResidualMassNumber << " " << TargetResidualCharge << " "
           << TargetResidualExcitationEnergy << G4endl;
    #endif
 
    G4int NumberOfTargetParticipant( 0 );
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfTarget[i];
      G4VSplitableHadron* targetSplitable = aNucleon->GetSplitableHadron();
      if ( targetSplitable->GetSoftCollisionCount() != 0 ) NumberOfTargetParticipant++;
    } 
 
    G4double DeltaExcitationE( 0.0 );
    G4LorentzVector DeltaPResidualNucleus = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
 
    if ( NumberOfTargetParticipant != 0 ) {
      DeltaExcitationE = TargetResidualExcitationEnergy / G4double( NumberOfTargetParticipant );
      DeltaPResidualNucleus = TargetResidual4Momentum / G4double( NumberOfTargetParticipant );
    }
 
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfTarget; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfTarget[i];
      G4VSplitableHadron* targetSplitable = aNucleon->GetSplitableHadron();
      if ( targetSplitable->GetSoftCollisionCount() != 0 ) {
        G4LorentzVector tmp = -DeltaPResidualNucleus;
        aNucleon->SetMomentum( tmp );
        aNucleon->SetBindingEnergy( DeltaExcitationE );
      } else {
        delete targetSplitable;  
        targetSplitable = 0; 
        aNucleon->Hit( targetSplitable );
        aNucleon->SetBindingEnergy( 0.0 );
      }
    } 
 
    #ifdef debugFTFmodel
    G4cout << "NumberOfTargetParticipant " << NumberOfTargetParticipant << G4endl
           << "TargetResidual4Momentum  " << TargetResidual4Momentum << G4endl;
    #endif
 
    if ( ! GetProjectileNucleus() ) return;  // The projectile is a hadron
 
    #ifdef debugFTFmodel
    G4cout << "Low energy interaction: Projectile nucleus --------------" << G4endl
           << "Pr ResidualMassNumber Pr ResidualCharge Pr ResidualExcitationEnergy "
           << ProjectileResidualMassNumber << " " << ProjectileResidualCharge << " "
           << ProjectileResidualExcitationEnergy << G4endl;
    #endif
 
    G4int NumberOfProjectileParticipant( 0 );
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfProjectile[i];
      G4VSplitableHadron* projectileSplitable = aNucleon->GetSplitableHadron();
      if ( projectileSplitable->GetSoftCollisionCount() != 0 ) NumberOfProjectileParticipant++;
    }
 
    #ifdef debugFTFmodel
    G4cout << "NumberOfProjectileParticipant" << G4endl;
    #endif
 
    DeltaExcitationE = 0.0;
    DeltaPResidualNucleus = G4LorentzVector( 0.0, 0.0, 0.0, 0.0 );
 
    if ( NumberOfProjectileParticipant != 0 ) {
      DeltaExcitationE = ProjectileResidualExcitationEnergy / G4double( NumberOfProjectileParticipant );
      DeltaPResidualNucleus = ProjectileResidual4Momentum / G4double( NumberOfProjectileParticipant );
    }
    //G4cout << "DeltaExcitationE DeltaPResidualNucleus " << DeltaExcitationE
    //       << " " << DeltaPResidualNucleus << G4endl;
    for ( G4int i = 0; i < NumberOfInvolvedNucleonsOfProjectile; ++i ) {
      G4Nucleon* aNucleon = TheInvolvedNucleonsOfProjectile[i];
      G4VSplitableHadron* projectileSplitable = aNucleon->GetSplitableHadron();
      if ( projectileSplitable->GetSoftCollisionCount() != 0 ) {
        G4LorentzVector tmp = -DeltaPResidualNucleus;
        aNucleon->SetMomentum( tmp );
        aNucleon->SetBindingEnergy( DeltaExcitationE );
      } else {
        delete projectileSplitable;  
        projectileSplitable = 0; 
        aNucleon->Hit( projectileSplitable );
        aNucleon->SetBindingEnergy( 0.0 );
      } 
    } 
 
    #ifdef debugFTFmodel
    G4cout << "NumberOfProjectileParticipant " << NumberOfProjectileParticipant << G4endl
           << "ProjectileResidual4Momentum " << ProjectileResidual4Momentum << G4endl;
    #endif
 
  }  // End of the condition: if ( HighEnergyInter )
 
  #ifdef debugFTFmodel
  G4cout << "End GetResiduals -----------------" << G4endl;
  #endif
 
}

References G4Nucleon::AreYouHit(), CLHEP::HepLorentzVector::boost(), C(), CLHEP::HepLorentzVector::findBoostToCM(), G4cout, G4endl, G4Nucleon::Get4Momentum(), G4Nucleon::GetBindingEnergy(), G4Nucleon::GetDefinition(), G4V3DNucleus::GetNextNucleon(), G4ParticleDefinition::GetPDGMass(), GetProjectileNucleus(), G4VSplitableHadron::GetSoftCollisionCount(), G4Nucleon::GetSplitableHadron(), G4VSplitableHadron::GetStatus(), GetTargetNucleus(), HighEnergyInter, G4Nucleon::Hit(), CLHEP::HepLorentzVector::mag(), CLHEP::Hep3Vector::mag2(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualMassNumber, G4Nucleon::SetBindingEnergy(), CLHEP::HepLorentzVector::setE(), G4Nucleon::SetMomentum(), sqr(), G4V3DNucleus::StartLoop(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, TargetResidualMassNumber, TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, and CLHEP::HepLorentzVector::vect().

Referenced by GetStrings().

◆ GetStrings()

G4ExcitedStringVector * G4FTFModel::GetStrings ( )

overrideprotectedvirtual

Implements G4VPartonStringModel.

Definition at line 298 of file G4FTFModel.cc.

                                              { 
 
  #ifdef debugFTFmodel
  G4cout << "G4FTFModel::GetStrings() " << G4endl;
  #endif
 
  G4ExcitedStringVector* theStrings = new G4ExcitedStringVector;
  theParticipants.GetList( theProjectile, theParameters );
 
  SetImpactParameter( theParticipants.GetImpactParameter() );
 
  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;
  #endif
 
  theParticipants.Clean();
 
  return theStrings;
}

References BuildStrings(), G4FTFParticipants::Clean(), ExciteParticipants(), G4cout, G4endl, G4FTFParticipants::GetImpactParameter(), G4FTFParticipants::GetInteraction(), G4FTFParticipants::GetList(), G4InteractionContent::GetProjectile(), GetProjectileNucleus(), GetResiduals(), G4Nucleon::GetSplitableHadron(), HighEnergyInter, G4FTFParticipants::Next(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, PutOnMassShell(), ReggeonCascade(), SetImpactParameter(), G4FTFParticipants::StartLoop(), StoreInvolvedNucleon(), TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, theParameters, theParticipants, and theProjectile.

◆ GetTargetNucleus()

G4V3DNucleus * G4FTFModel::GetTargetNucleus ( ) const

inline

Definition at line 216 of file G4FTFModel.hh.

                                                        {
  return theParticipants.GetWoundedNucleus();
}

References G4VParticipants::GetWoundedNucleus(), and theParticipants.

Referenced by GetResiduals(), PutOnMassShell(), ReggeonCascade(), and StoreInvolvedNucleon().

◆ GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const

inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

110 { return verboseLevel; }

G4HadronicInteraction::verboseLevel

G4int verboseLevel

Definition: G4HadronicInteraction.hh:177

References G4HadronicInteraction::verboseLevel.

◆ GetWoundedNucleus()

G4V3DNucleus * G4FTFModel::GetWoundedNucleus ( ) const

inlineoverridevirtual

Implements G4VHighEnergyGenerator.

Definition at line 212 of file G4FTFModel.hh.

                                                         {
  return theParticipants.GetWoundedNucleus();
}

References G4VParticipants::GetWoundedNucleus(), and theParticipants.

◆ Init()

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

overrideprotectedvirtual

Implements G4VPartonStringModel.

Definition at line 162 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;
  ProjectileResidualLambdaNumber     = 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
    ProjectileResidualMassNumber = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
    ProjectileResidualCharge = G4int( theProjectile.GetDefinition()->GetPDGCharge() );
    PlabPerParticle = theProjectile.GetMomentum().z();
    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      
      ProjectileResidualMassNumber = theProjectile.GetDefinition()->GetBaryonNumber();
      ProjectileResidualCharge = G4int( theProjectile.GetDefinition()->GetPDGCharge() );
      ProjectileResidualLambdaNumber = theProjectile.GetDefinition()->GetNumberOfLambdasInHypernucleus();
      PlabPerParticle = theProjectile.GetMomentum().z() / ProjectileResidualMassNumber;
      if ( PlabPerParticle < LowEnergyLimit ) {
        HighEnergyInter = false;
      } else {
        HighEnergyInter = true;
      }
      theParticipants.InitProjectileNucleus( ProjectileResidualMassNumber, ProjectileResidualCharge,
                         ProjectileResidualLambdaNumber );
    } else if ( theProjectile.GetDefinition()->GetBaryonNumber() < -1 ) { 
      // Projectile is an anti-nucleus
      ProjectileResidualMassNumber = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
      ProjectileResidualCharge = std::abs( G4int( theProjectile.GetDefinition()->GetPDGCharge() ) );
      ProjectileResidualLambdaNumber = theProjectile.GetDefinition()->GetNumberOfAntiLambdasInAntiHypernucleus();
      PlabPerParticle = theProjectile.GetMomentum().z() / ProjectileResidualMassNumber;
      if ( PlabPerParticle < LowEnergyLimit ) {
        HighEnergyInter = false;
      } else {
        HighEnergyInter = true;
      }
      theParticipants.InitProjectileNucleus( ProjectileResidualMassNumber, ProjectileResidualCharge,
                                             ProjectileResidualLambdaNumber );
      theParticipants.GetProjectileNucleus()->StartLoop();
      G4Nucleon* aNucleon;
      while ( ( aNucleon = theParticipants.GetProjectileNucleus()->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
        if ( aNucleon->GetDefinition() == G4Proton::Definition() ) {
          aNucleon->SetParticleType( G4AntiProton::Definition() ); 
        } else if ( aNucleon->GetDefinition() == G4Neutron::Definition() ) {
          aNucleon->SetParticleType( G4AntiNeutron::Definition() );
        } else if ( aNucleon->GetDefinition() == G4Lambda::Definition() ) {
      aNucleon->SetParticleType( G4AntiLambda::Definition() );
    }
      }
    }
 
    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 (assumed to be never a hypernucleus)
  theParticipants.Init( aNucleus.GetA_asInt(), aNucleus.GetZ_asInt() );
 
  NumberOfProjectileSpectatorNucleons = std::abs( theProjectile.GetDefinition()->GetBaryonNumber() );
  NumberOfTargetSpectatorNucleons = aNucleus.GetA_asInt();
  NumberOfNNcollisions = 0;
 
  // 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 );
 
  if ( SampleBinInterval() ) theParticipants.SetBminBmax( GetBmin(), GetBmax() );
}

References G4FTFParticipants::Clean(), G4AntiLambda::Definition(), G4AntiNeutron::Definition(), G4AntiProton::Definition(), G4Lambda::Definition(), G4Neutron::Definition(), G4Proton::Definition(), G4V3DNucleus::DoLorentzBoost(), G4V3DNucleus::DoLorentzContraction(), G4cout, G4endl, G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetBaryonNumber(), GetBmax(), GetBmin(), G4Nucleon::GetDefinition(), G4ReactionProduct::GetDefinition(), G4IonTable::GetIonMass(), G4ParticleTable::GetIonTable(), G4ReactionProduct::GetMass(), G4ReactionProduct::GetMomentum(), G4V3DNucleus::GetNextNucleon(), G4ParticleDefinition::GetNumberOfAntiLambdasInAntiHypernucleus(), G4ParticleDefinition::GetNumberOfLambdasInHypernucleus(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), G4VParticipants::GetProjectileNucleus(), G4ReactionProduct::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), HighEnergyInter, G4VParticipants::Init(), G4FTFParameters::InitForInteraction(), G4VParticipants::InitProjectileNucleus(), LowEnergyLimit, NumberOfNNcollisions, NumberOfProjectileSpectatorNucleons, NumberOfTargetSpectatorNucleons, ProjectileResidual4Momentum, ProjectileResidualCharge, ProjectileResidualExcitationEnergy, ProjectileResidualLambdaNumber, ProjectileResidualMassNumber, SampleBinInterval(), G4FTFParticipants::SetBminBmax(), CLHEP::HepLorentzVector::setE(), G4Nucleon::SetParticleType(), G4FTFParameters::SetProbabilityOfElasticScatt(), G4VParticipants::SetProjectileNucleus(), CLHEP::HepLorentzVector::setVect(), G4V3DNucleus::StartLoop(), TargetResidual4Momentum, TargetResidualCharge, TargetResidualExcitationEnergy, TargetResidualMassNumber, theAdditionalString, theParameters, theParticipants, theProjectile, and CLHEP::Hep3Vector::z().

◆ InitialiseModel()

void G4HadronicInteraction::InitialiseModel ( )

virtualinherited

Reimplemented in G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4AblaInterface, G4NeutronRadCapture, G4LowEGammaNuclearModel, G4PreCompoundModel, and G4ElasticHadrNucleusHE.

Definition at line 59 of file G4HadronicInteraction.cc.

60{}

◆ IsApplicable()

G4bool G4HadronicInteraction::IsApplicable	(	const G4HadProjectile &	aTrack,
		G4Nucleus &	targetNucleus
	)

virtualinherited

Reimplemented in G4DiffuseElastic, G4DiffuseElasticV2, G4hhElastic, G4NeutrinoElectronNcModel, G4NeutronElectronElModel, G4ANuElNucleusCcModel, G4ANuElNucleusNcModel, G4ANuMuNucleusCcModel, G4ANuMuNucleusNcModel, G4NeutrinoElectronCcModel, G4NeutrinoNucleusModel, G4NuElNucleusCcModel, G4NuElNucleusNcModel, G4NuMuNucleusCcModel, G4NuMuNucleusNcModel, G4CascadeInterface, and G4LMsdGenerator.

Definition at line 75 of file G4HadronicInteraction.cc.

{ 
  return true;
}

◆ IsBlocked() [1/3]

G4bool G4HadronicInteraction::IsBlocked ( ) const

inlineprotectedinherited

Definition at line 169 of file G4HadronicInteraction.hh.

169{ return isBlocked;}

References G4HadronicInteraction::isBlocked.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::GetMinEnergy().

◆ IsBlocked() [2/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Element * anElement ) const

inherited

Definition at line 202 of file G4HadronicInteraction.cc.

{
  for (auto const& elm : theBlockedListElements) {
    if (anElement == elm) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedListElements.

◆ IsBlocked() [3/3]

G4bool G4HadronicInteraction::IsBlocked ( const G4Material * aMaterial ) const

inherited

Definition at line 193 of file G4HadronicInteraction.cc.

{
  for (auto const& mat : theBlockedList) {
    if (aMaterial == mat) return true;
  }
  return false;
}

References G4HadronicInteraction::theBlockedList.

◆ ModelDescription()

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

overridevirtual

Reimplemented from G4VHighEnergyGenerator.

Definition at line 3092 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!=() [1/4]

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

delete

◆ operator!=() [2/4]

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

deleteinherited

◆ operator!=() [3/4]

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

deleteinherited

◆ operator!=() [4/4]

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

deleteinherited

◆ operator=()

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

delete

◆ operator==() [1/4]

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

delete

◆ operator==() [2/4]

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

deleteinherited

◆ operator==() [3/4]

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

deleteinherited

◆ operator==() [4/4]

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

deleteinherited

◆ PutOnMassShell()

G4bool G4FTFModel::PutOnMassShell ( )

private

Definition at line 559 of file G4FTFModel.cc.

                                  {
 
  G4bool isProjectileNucleus = false;
  if ( GetProjectileNucleus() ) isProjectileNucleus = true;
 
  #ifdef debugPutOnMassShell
  G4cout << "PutOnMassShell start " << G4endl;
  if ( isProjectileNucleus ) {
    G4cout << "PutOnMassShell for Nucleus_Nucleus " << G4endl;
  }
  #endif
 
  G4LorentzVector Pprojectile( theProjectile.GetMomentum(), theProjectile.GetTotalEnergy() );
  if ( Pprojectile.z() < 0.0 ) return false;
 
  G4bool isOk = true;
  
  G4LorentzVector Ptarget( 0.0, 0.0, 0.0, 0.0 );
  G4LorentzVector PtargetResidual( 0.0, 0.0, 0.0, 0.0 );
  G4double SumMasses = 0.0;
  G4V3DNucleus* theTargetNucleus = GetTargetNucleus();
  G4double TargetResidualMass = 0.0; 
 
  #ifdef debugPutOnMassShell
  G4cout << "Target : ";
  #endif
  isOk = ComputeNucleusProperties( theTargetNucleus, Ptarget, PtargetResidual, SumMasses,
                                   TargetResidualExcitationEnergy, TargetResidualMass,
                                   TargetResidualMassNumber, TargetResidualCharge );
  if ( ! isOk ) return false;
 
  G4double Mprojectile  = 0.0;
  G4double M2projectile = 0.0;
  G4LorentzVector Pproj( 0.0, 0.0, 0.0, 0.0 );
  G4LorentzVector PprojResidual( 0.0, 0.0, 0.0, 0.0 );
  G4V3DNucleus* thePrNucleus = GetProjectileNucleus();
  G4double PrResidualMass = 0.0;
 
  if ( ! isProjectileNucleus ) {  // hadron-nucleus collision
    Mprojectile  = Pprojectile.mag();
    M2projectile = Pprojectile.mag2();
    SumMasses += Mprojectile + 20.0*MeV;
  } else {  // nucleus-nucleus or antinucleus-nucleus collision
    #ifdef debugPutOnMassShell
    G4cout << "Projectile : ";
    #endif
    isOk = ComputeNucleusProperties( thePrNucleus, Pproj, PprojResidual, SumMasses,
                                     ProjectileResidualExcitationEnergy, PrResidualMass,
                                     ProjectileResidualMassNumber, ProjectileResidualCharge );
    if ( ! isOk ) return false;
  }
 
  G4LorentzVector Psum = Pprojectile + Ptarget;   
  G4double SqrtS = Psum.mag();
  G4double     S = Psum.mag2();
 
  #ifdef debugPutOnMassShell
  G4cout << "Psum " << Psum/GeV << " GeV" << G4endl << "SqrtS " << SqrtS/GeV << " GeV" << G4endl
         << "SumMasses, PrResidualMass and TargetResidualMass " << SumMasses/GeV << " " 
         << PrResidualMass/GeV << " " << TargetResidualMass/GeV << " GeV" << G4endl;
  #endif
 
  if ( SqrtS < SumMasses ) return false;  // It is impossible to simulate after putting nuclear nucleons on mass-shell
 
  // Try to consider also the excitation energy of the residual nucleus, if this is
  // possible, with the available energy; otherwise, set the excitation energy to zero.
  G4double savedSumMasses = SumMasses;
  if ( isProjectileNucleus ) {
    SumMasses -= std::sqrt( sqr( PrResidualMass ) + PprojResidual.perp2() );
    SumMasses += std::sqrt( sqr( PrResidualMass + ProjectileResidualExcitationEnergy ) 
                            + PprojResidual.perp2() ); 
  }
  SumMasses -= std::sqrt( sqr( TargetResidualMass ) + PtargetResidual.perp2() );
  SumMasses += std::sqrt( sqr( TargetResidualMass + TargetResidualExcitationEnergy )
                          + PtargetResidual.perp2() );
 
  if ( SqrtS < SumMasses ) {
    SumMasses = savedSumMasses;
    if ( isProjectileNucleus ) ProjectileResidualExcitationEnergy = 0.0;
    TargetResidualExcitationEnergy = 0.0;
  }
 
  TargetResidualMass += TargetResidualExcitationEnergy;
  if ( isProjectileNucleus ) PrResidualMass += ProjectileResidualExcitationEnergy;
 
  #ifdef debugPutOnMassShell
  if ( isProjectileNucleus ) {
    G4cout << "PrResidualMass ProjResidualExcitationEnergy " << PrResidualMass/GeV << " "
       << ProjectileResidualExcitationEnergy << " MeV" << G4endl;
  }
  G4cout << "TargetResidualMass TargetResidualExcitationEnergy " << TargetResidualMass/GeV << " " 
         << TargetResidualExcitationEnergy << " MeV" << G4endl
         << "Sum masses " << SumMasses/GeV << G4endl;
  #endif
 
  // Sampling of nucleons what can transfer to delta-isobars
  if ( isProjectileNucleus  &&  thePrNucleus->GetMassNumber() != 1 ) {
      isOk = GenerateDeltaIsobar( SqrtS, NumberOfInvolvedNucleonsOfProjectile,
                                  TheInvolvedNucleonsOfProjectile, SumMasses );       
  }
  if ( theTargetNucleus->GetMassNumber() != 1 ) {
    isOk = isOk  &&  GenerateDeltaIsobar( SqrtS, NumberOfInvolvedNucleonsOfTarget,
                                          TheInvolvedNucleonsOfTarget, SumMasses );
  }
  if ( ! isOk ) return false;
 
  // Now we know that it is kinematically possible to produce a final state made
  // of the involved nucleons (or corresponding delta-isobars) and a residual nucleus.
  // We have to sample the kinematical variables which will allow to define the 4-momenta
  // of the final state. The sampled kinematical variables refer to the center-of-mass frame.
  // Notice that the sampling of the transverse momentum corresponds to take into account
  // Fermi motion.
 
  G4LorentzRotation toCms( -1*Psum.boostVector() );
  G4LorentzVector Ptmp = toCms*Pprojectile;
  if ( Ptmp.pz() <= 0.0 ) return false;  // "String" moving backwards in c.m.s., abort collision!
 
  G4LorentzRotation toLab( toCms.inverse() );
  
  G4double YprojectileNucleus = 0.0;
  if ( isProjectileNucleus ) {
    Ptmp = toCms*Pproj;                      
    YprojectileNucleus = Ptmp.rapidity();
  }
  Ptmp = toCms*Ptarget;                      
  G4double YtargetNucleus = Ptmp.rapidity();
 
  // Ascribing of the involved nucleons Pt and Xminus
  G4double DcorP = 0.0;
  if ( isProjectileNucleus ) DcorP = theParameters->GetDofNuclearDestruction() / thePrNucleus->GetMassNumber();
  G4double DcorT       = theParameters->GetDofNuclearDestruction() / theTargetNucleus->GetMassNumber();
  G4double AveragePt2  = theParameters->GetPt2ofNuclearDestruction();
  G4double maxPtSquare = theParameters->GetMaxPt2ofNuclearDestruction();
 
  #ifdef debugPutOnMassShell
  if ( isProjectileNucleus ) {
    G4cout << "Y projectileNucleus " << YprojectileNucleus << G4endl;
  }
  G4cout << "Y targetNucleus     " << YtargetNucleus << G4endl 
         << "Dcor " << theParameters->GetDofNuclearDestruction()
         << " DcorP DcorT " << DcorP << " " << DcorT << " AveragePt2 " << AveragePt2 << G4endl;
  #endif
 
  G4double M2proj = M2projectile;  // Initialization needed only for hadron-nucleus collisions
  G4double WplusProjectile = 0.0;
  G4double M2target = 0.0;
  G4double WminusTarget = 0.0;
  G4int NumberOfTries = 0;
  G4double ScaleFactor = 1.0;
  G4bool OuterSuccess = true;
 
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do {  // while ( ! OuterSuccess )
    OuterSuccess = true;
    const G4int maxNumberOfInnerLoops = 10000;
    do {  // while ( SqrtS < Mprojectile + std::sqrt( M2target ) )
      NumberOfTries++;
      if ( NumberOfTries == 100*(NumberOfTries/100) ) {
        // After many tries, it is convenient to reduce the values of DcorP, DcorT and
        // AveragePt2, so that the sampled momenta (respectively, pz, and pt) of the
    // involved nucleons (or corresponding delta-isomers) are smaller, and therefore
        // it is more likely to satisfy the momentum conservation.
        ScaleFactor /= 2.0;
        DcorP       *= ScaleFactor;
        DcorT       *= ScaleFactor;
        AveragePt2  *= ScaleFactor;
      }
      if ( isProjectileNucleus ) {
        // Sampling of kinematical properties of projectile nucleons
        isOk = SamplingNucleonKinematics( AveragePt2, maxPtSquare, DcorP, 
                                          thePrNucleus, PprojResidual, 
                                          PrResidualMass, ProjectileResidualMassNumber,
                                          NumberOfInvolvedNucleonsOfProjectile, 
                                          TheInvolvedNucleonsOfProjectile, M2proj );
      }
      // Sampling of kinematical properties of target nucleons
      isOk = isOk  &&  SamplingNucleonKinematics( AveragePt2, maxPtSquare, DcorT, 
                                                  theTargetNucleus, PtargetResidual, 
                                                  TargetResidualMass, TargetResidualMassNumber,
                                                  NumberOfInvolvedNucleonsOfTarget, 
                                                  TheInvolvedNucleonsOfTarget, M2target );
      #ifdef debugPutOnMassShell
      G4cout << "SqrtS, Mp+Mt, Mp, Mt " << SqrtS/GeV << " " 
             << ( std::sqrt( M2proj ) + std::sqrt( M2target) )/GeV << " "
             << std::sqrt( M2proj )/GeV << " " << std::sqrt( M2target )/GeV << G4endl;
      #endif
      if ( ! isOk ) return false;
    } while ( ( SqrtS < std::sqrt( M2proj ) + std::sqrt( M2target ) ) &&
              NumberOfTries < maxNumberOfInnerLoops );  /* Loop checking, 10.08.2015, A.Ribon */
    if ( NumberOfTries >= maxNumberOfInnerLoops ) {
      #ifdef debugPutOnMassShell
      G4cout << "BAD situation: forced exit of the inner while loop!" << G4endl;
      #endif
      return false;
    }
    if ( isProjectileNucleus ) {
      isOk = CheckKinematics( S, SqrtS, M2proj, M2target, YprojectileNucleus, true, 
                              NumberOfInvolvedNucleonsOfProjectile, 
                              TheInvolvedNucleonsOfProjectile,
                              WminusTarget, WplusProjectile, OuterSuccess );
    }
    isOk = isOk  &&  CheckKinematics( S, SqrtS, M2proj, M2target, YtargetNucleus, false, 
                                      NumberOfInvolvedNucleonsOfTarget, TheInvolvedNucleonsOfTarget,
                                      WminusTarget, WplusProjectile, OuterSuccess );
    if ( ! isOk ) return false;
  } while ( ( ! OuterSuccess ) &&
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
  if ( loopCounter >= maxNumberOfLoops ) {
    #ifdef debugPutOnMassShell
    G4cout << "BAD situation: forced exit of the while loop!" << G4endl;
    #endif
    return false;
  }
 
  // Now the sampling is completed, and we can determine the kinematics of the
  // whole system. This is done first in the center-of-mass frame, and then it is boosted
  // to the lab frame. The transverse momentum of the residual nucleus is determined as
  // the recoil of each hadron (nucleon or delta) which is emitted, i.e. in such a way
  // to conserve (by construction) the transverse momentum.
 
  if ( ! isProjectileNucleus ) {  // hadron-nucleus collision
 
    G4double Pzprojectile = WplusProjectile/2.0 - M2projectile/2.0/WplusProjectile;
    G4double Eprojectile  = WplusProjectile/2.0 + M2projectile/2.0/WplusProjectile;
    Pprojectile.setPz( Pzprojectile ); 
    Pprojectile.setE( Eprojectile );
 
    #ifdef debugPutOnMassShell
    G4cout << "Proj after in CMS " << Pprojectile << G4endl;
    #endif
 
    Pprojectile.transform( toLab );  
    theProjectile.SetMomentum( Pprojectile.vect() );
    theProjectile.SetTotalEnergy( Pprojectile.e() );
 
    theParticipants.StartLoop();
    theParticipants.Next();
    G4VSplitableHadron* primary = theParticipants.GetInteraction().GetProjectile();
    primary->Set4Momentum( Pprojectile ); 
 
    #ifdef debugPutOnMassShell
    G4cout << "Final proj. mom in Lab. " << primary->Get4Momentum() << G4endl;
    #endif
 
  } else {  // nucleus-nucleus or antinucleus-nucleus collision
 
    isOk = FinalizeKinematics( WplusProjectile, true, toLab, PrResidualMass, 
                               ProjectileResidualMassNumber, NumberOfInvolvedNucleonsOfProjectile,
                               TheInvolvedNucleonsOfProjectile, ProjectileResidual4Momentum );
 
    #ifdef debugPutOnMassShell
    G4cout << "Projectile Residual4Momentum in CMS " << ProjectileResidual4Momentum << G4endl;
    #endif
 
    if ( ! isOk ) return false;
 
    ProjectileResidual4Momentum.transform( toLab );
 
    #ifdef debugPutOnMassShell
    G4cout << "Projectile Residual4Momentum in Lab " << ProjectileResidual4Momentum << G4endl;
    #endif
 
  }
 
  isOk = FinalizeKinematics( WminusTarget, false, toLab, TargetResidualMass, 
                             TargetResidualMassNumber, NumberOfInvolvedNucleonsOfTarget,
                             TheInvolvedNucleonsOfTarget, TargetResidual4Momentum );
 
  #ifdef debugPutOnMassShell
  G4cout << "Target Residual4Momentum in CMS " << TargetResidual4Momentum << G4endl;
  #endif
 
  if ( ! isOk ) return false;
 
  TargetResidual4Momentum.transform( toLab );
 
  #ifdef debugPutOnMassShell
  G4cout << "Target Residual4Momentum in Lab " << TargetResidual4Momentum << G4endl;
  #endif
 
  return true;
 
}

Referenced by GetStrings().

◆ ReggeonCascade()

void G4FTFModel::ReggeonCascade ( )

private

Definition at line 456 of file G4FTFModel.cc.

                                { 
  // Implementation of the reggeon theory inspired model
 
  #ifdef debugReggeonCascade
  G4cout << "G4FTFModel::ReggeonCascade -----------" << G4endl
         << "theProjectile.GetTotalMomentum() " << theProjectile.GetTotalMomentum() << G4endl
         << "theProjectile.GetTotalEnergy() " << theProjectile.GetTotalEnergy() << G4endl
         << "ExcitationE/WN " << theParameters->GetExcitationEnergyPerWoundedNucleon() << G4endl;
  #endif
 
  G4int InitNINt = NumberOfInvolvedNucleonsOfTarget;
 
  // Reggeon cascading in target nucleus
  for ( G4int InvTN = 0; InvTN < InitNINt; InvTN++ ) { 
    G4Nucleon* aTargetNucleon = TheInvolvedNucleonsOfTarget[ InvTN ];
 
    G4double CreationTime = aTargetNucleon->GetSplitableHadron()->GetTimeOfCreation();
 
    G4double XofWoundedNucleon = aTargetNucleon->GetPosition().x();
    G4double YofWoundedNucleon = aTargetNucleon->GetPosition().y();
           
    G4V3DNucleus* theTargetNucleus = GetTargetNucleus();
    theTargetNucleus->StartLoop();
 
    G4Nucleon* Neighbour(0);
    while ( ( Neighbour = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
      if ( ! Neighbour->AreYouHit() ) {
        G4double impact2 = sqr( XofWoundedNucleon - Neighbour->GetPosition().x() ) +
                           sqr( YofWoundedNucleon - Neighbour->GetPosition().y() );
 
        if ( G4UniformRand() < theParameters->GetCofNuclearDestruction() *
                               G4Exp( -impact2 / theParameters->GetR2ofNuclearDestruction() )
           ) {  
          // The neighbour nucleon is involved in the reggeon cascade
          TheInvolvedNucleonsOfTarget[ NumberOfInvolvedNucleonsOfTarget ] = Neighbour;
          NumberOfInvolvedNucleonsOfTarget++;
 
          G4VSplitableHadron* targetSplitable; 
          targetSplitable = new G4DiffractiveSplitableHadron( *Neighbour ); 
 
          Neighbour->Hit( targetSplitable );
          targetSplitable->SetTimeOfCreation( CreationTime ); 
          targetSplitable->SetStatus( 3 );  // 2->3
        }
      }
    }
  }
 
  #ifdef debugReggeonCascade
  G4cout << "Final NumberOfInvolvedNucleonsOfTarget " 
         << NumberOfInvolvedNucleonsOfTarget << G4endl << G4endl;
  #endif
 
  if ( ! GetProjectileNucleus() ) return;
 
  // Nucleus-Nucleus Interaction : Destruction of Projectile
  G4int InitNINp = NumberOfInvolvedNucleonsOfProjectile;
 
  //for ( G4int InvPN = 0; InvPN < NumberOfInvolvedNucleonsOfProjectile; InvPN++ ) { 
  for ( G4int InvPN = 0; InvPN < InitNINp; InvPN++ ) { 
    G4Nucleon* aProjectileNucleon = TheInvolvedNucleonsOfProjectile[ InvPN ];
 
    G4double CreationTime = aProjectileNucleon->GetSplitableHadron()->GetTimeOfCreation();
 
    G4double XofWoundedNucleon = aProjectileNucleon->GetPosition().x();
    G4double YofWoundedNucleon = aProjectileNucleon->GetPosition().y();
           
    G4V3DNucleus* theProjectileNucleus = GetProjectileNucleus();
    theProjectileNucleus->StartLoop();
 
    G4Nucleon* Neighbour( 0 );
    while ( ( Neighbour = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
      if ( ! Neighbour->AreYouHit() ) {
        G4double impact2= sqr( XofWoundedNucleon - Neighbour->GetPosition().x() ) +
                          sqr( YofWoundedNucleon - Neighbour->GetPosition().y() );
 
        if ( G4UniformRand() < theParameters->GetCofNuclearDestructionPr() * 
                               G4Exp( -impact2 / theParameters->GetR2ofNuclearDestruction() )
           ) {
          // The neighbour nucleon is involved in the reggeon cascade
          TheInvolvedNucleonsOfProjectile[ NumberOfInvolvedNucleonsOfProjectile ] = Neighbour;
          NumberOfInvolvedNucleonsOfProjectile++;
 
          G4VSplitableHadron* projectileSplitable; 
          projectileSplitable = new G4DiffractiveSplitableHadron( *Neighbour ); 
 
          Neighbour->Hit( projectileSplitable );
          projectileSplitable->SetTimeOfCreation( CreationTime );
          projectileSplitable->SetStatus( 3 );
        }
      }
    }
  }
 
  #ifdef debugReggeonCascade
  G4cout << "NumberOfInvolvedNucleonsOfProjectile "
         << NumberOfInvolvedNucleonsOfProjectile << G4endl << G4endl;
  #endif
}   

References G4Nucleon::AreYouHit(), G4cout, G4endl, G4Exp(), G4UniformRand, G4FTFParameters::GetCofNuclearDestruction(), G4FTFParameters::GetCofNuclearDestructionPr(), G4FTFParameters::GetExcitationEnergyPerWoundedNucleon(), G4V3DNucleus::GetNextNucleon(), G4Nucleon::GetPosition(), GetProjectileNucleus(), G4FTFParameters::GetR2ofNuclearDestruction(), G4Nucleon::GetSplitableHadron(), GetTargetNucleus(), G4VSplitableHadron::GetTimeOfCreation(), G4ReactionProduct::GetTotalEnergy(), G4ReactionProduct::GetTotalMomentum(), G4Nucleon::Hit(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, G4VSplitableHadron::SetStatus(), G4VSplitableHadron::SetTimeOfCreation(), sqr(), G4V3DNucleus::StartLoop(), TheInvolvedNucleonsOfProjectile, TheInvolvedNucleonsOfTarget, theParameters, theProjectile, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by GetStrings().

◆ SampleBinInterval()

G4bool G4FTFModel::SampleBinInterval ( ) const

inline

Definition at line 240 of file G4FTFModel.hh.

                                                  {
  return BinInterval;
}

References BinInterval.

Referenced by Init().

◆ SampleInvariantT()

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

virtualinherited

Reimplemented in G4ChipsElasticModel, G4DiffuseElastic, G4DiffuseElasticV2, G4NuclNuclDiffuseElastic, G4AntiNuclElastic, G4ElasticHadrNucleusHE, G4HadronElastic, G4LEHadronProtonElastic, G4LEnp, G4LEpp, G4LowEHadronElastic, and G4hhElastic.

Definition at line 69 of file G4HadronicInteraction.cc.

{
  return 0.0;
}

◆ SamplingNucleonKinematics()

G4bool G4FTFModel::SamplingNucleonKinematics	(	G4double	averagePt2,
		const G4double	maxPt2,
		G4double	dCor,
		G4V3DNucleus *	nucleus,
		const G4LorentzVector &	pResidual,
		const G4double	residualMass,
		const G4int	residualMassNumber,
		const G4int	numberOfInvolvedNucleons,
		G4Nucleon *	involvedNucleons[],
		G4double &	mass2
	)

private

Definition at line 2789 of file G4FTFModel.cc.

                                             {                    // output parameter
 
  // This method, which is called only by PutOnMassShell, does the sampling of:
  // -  either the target nucleons: this for any kind of hadronic interactions
  //    (hadron-nucleus, nucleus-nucleus, antinucleus-nucleus);
  // -  or the projectile nucleons or antinucleons: this only in the case of
  //    nucleus-nucleus or antinucleus-nucleus interactions, respectively.
  // This method assumes that all the parameters have been initialized by the caller;
  // the action of this method consists in changing the properties of the nucleons
  // whose pointers are in the vector involvedNucleons, as well as changing the
  // variable mass2.
#ifdef debugPutOnMassShell
  G4cout << "G4FTFModel::SamplingNucleonKinematics:" << G4endl;
  G4cout << " averagePt2= " << averagePt2 << " maxPt2= " << maxPt2
     << " dCor= " << dCor << " resMass(GeV)= " << residualMass/GeV
     << " resMassN= " << residualMassNumber 
         << " nNuc= " << numberOfInvolvedNucleons
     << " lv= " << pResidual << G4endl;   
#endif
 
  if ( ! nucleus  ||  numberOfInvolvedNucleons < 1 ) return false;
 
  if ( residualMassNumber == 0  &&  numberOfInvolvedNucleons == 1 ) {
    dCor = 0.0; 
    averagePt2 = 0.0;
  } 
 
  G4bool success = true;                            
 
  G4double SumMasses = residualMass; 
  G4double invN = 1.0 / (G4double)numberOfInvolvedNucleons;
 
  // to avoid problems due to precision lost a tolerance is added
  const G4double eps = 1.e-10;  
  const G4int maxNumberOfLoops = 1000;
  G4int loopCounter = 0;
  do {
 
    success = true;
 
    // Sampling of nucleon Pt 
    G4ThreeVector ptSum( 0.0, 0.0, 0.0 );
    if( averagePt2 > 0.0 ) {
      for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
    G4Nucleon* aNucleon = involvedNucleons[i];
    if ( ! aNucleon ) continue;
    G4ThreeVector tmpPt = GaussianPt( averagePt2, maxPt2 );
    ptSum += tmpPt;
    G4LorentzVector tmp( tmpPt.x(), tmpPt.y(), 0.0, 0.0 );
    aNucleon->SetMomentum( tmp );
      }
    }
 
    G4double deltaPx = ( ptSum.x() - pResidual.x() )*invN;
    G4double deltaPy = ( ptSum.y() - pResidual.y() )*invN;
 
    SumMasses = residualMass;
    for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
      G4Nucleon* aNucleon = involvedNucleons[i];
      if ( ! aNucleon ) continue;
      G4double px = aNucleon->Get4Momentum().px() - deltaPx;
      G4double py = aNucleon->Get4Momentum().py() - deltaPy;
      G4double MtN = std::sqrt( sqr( aNucleon->GetSplitableHadron()->GetDefinition()->GetPDGMass() )
                                + sqr( px ) + sqr( py ) );
      SumMasses += MtN;
      G4LorentzVector tmp( px, py, 0.0, MtN);
      aNucleon->SetMomentum( tmp );
    }
 
    // Sampling X of nucleon
    G4double xSum = 0.0;
 
    for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
      G4Nucleon* aNucleon = involvedNucleons[i];
      if ( ! aNucleon ) continue;
     
      G4double x = 0.0;
      if( 0.0 != dCor ) {
    G4ThreeVector tmpX = GaussianPt( dCor*dCor, 1.0 );
        x = tmpX.x();
      } 
      x += aNucleon->Get4Momentum().e()/SumMasses;
      if ( x < -eps  ||  x > 1.0 + eps ) { 
        success = false; 
        break;
      }
      x = std::min(1.0, std::max(x, 0.0));
      xSum += x;
      // The energy is in the lab (instead of cms) frame but it will not be used
 
      G4LorentzVector tmp( aNucleon->Get4Momentum().x(), 
                           aNucleon->Get4Momentum().y(), 
                           x, aNucleon->Get4Momentum().e() );
      aNucleon->SetMomentum( tmp );
    }
 
    if ( xSum < -eps || xSum > 1.0 + eps ) success = false;
    if ( ! success ) continue;
 
    G4double delta = ( residualMassNumber == 0 ) ? std::min( xSum - 1.0, 0.0 )*invN : 0.0;
 
    xSum = 1.0;
    mass2 = 0.0;
    for ( G4int i = 0; i < numberOfInvolvedNucleons; ++i ) {
      G4Nucleon* aNucleon = involvedNucleons[i];
      if ( ! aNucleon ) continue;
      G4double x = aNucleon->Get4Momentum().pz() - delta;
      xSum -= x;
 
      if ( residualMassNumber == 0 ) {
        if ( x <= -eps || x > 1.0 + eps ) {
          success = false; 
          break;
        }
      } else {
        if ( x <= -eps || x > 1.0 + eps || xSum <= -eps || xSum > 1.0 + eps ) {
          success = false; 
          break;
        }
      } 
      x = std::min( 1.0, std::max(x, eps) );
 
      mass2 += sqr( aNucleon->Get4Momentum().e() ) / x;
 
      G4LorentzVector tmp( aNucleon->Get4Momentum().px(), aNucleon->Get4Momentum().py(), 
                           x, aNucleon->Get4Momentum().e() );
      aNucleon->SetMomentum( tmp );
    }
    if ( ! success ) continue;
    xSum = std::min( 1.0, std::max(xSum, eps) );
 
    if ( residualMassNumber > 0 ) mass2 += ( sqr( residualMass ) + pResidual.perp2() ) / xSum;
    
    #ifdef debugPutOnMassShell
    G4cout << "success: " << success << " Mt(GeV)= " 
       << std::sqrt( mass2 )/GeV << G4endl;
    #endif
 
  } while ( ( ! success ) &&
            ++loopCounter < maxNumberOfLoops );  /* Loop checking, 10.08.2015, A.Ribon */
  return ( loopCounter < maxNumberOfLoops );
}

References CLHEP::HepLorentzVector::e(), eps, G4cout, G4endl, GaussianPt(), G4Nucleon::Get4Momentum(), G4VSplitableHadron::GetDefinition(), G4ParticleDefinition::GetPDGMass(), G4Nucleon::GetSplitableHadron(), GeV, G4INCL::Math::max(), G4INCL::Math::min(), CLHEP::HepLorentzVector::perp2(), CLHEP::HepLorentzVector::px(), CLHEP::HepLorentzVector::py(), CLHEP::HepLorentzVector::pz(), G4Nucleon::SetMomentum(), sqr(), CLHEP::HepLorentzVector::x(), CLHEP::Hep3Vector::x(), CLHEP::HepLorentzVector::y(), and CLHEP::Hep3Vector::y().

Referenced by PutOnMassShell().

◆ Scatter()

G4KineticTrackVector * G4VPartonStringModel::Scatter	(	const G4Nucleus &	theNucleus,
		const G4DynamicParticle &	thePrimary
	)

overridevirtualinherited

Implements G4VHighEnergyGenerator.

Definition at line 63 of file G4VPartonStringModel.cc.

{  
  G4ExcitedStringVector * strings = nullptr;
  G4DynamicParticle thePrimary=aPrimary;
  G4LorentzVector SumStringMom(0.,0.,0.,0.);
  G4KineticTrackVector * theResult = 0;
  G4Nucleon * theNuclNucleon(nullptr);
 
  #ifdef debug_PartonStringModel
  G4cout<<G4endl;
  G4cout<<"-----------------------Parton-String model is runnung ------------"<<G4endl;
  G4cout<<"Projectile Name Mass "<<thePrimary.GetDefinition()->GetParticleName()<<" "
                                 <<thePrimary.GetMass()<<G4endl;
  G4cout<<"           Momentum  "<<thePrimary.Get4Momentum()<<G4endl;
  G4cout<<"Target nucleus   A Z "<<theNucleus.GetA_asInt()<<" "
                                 <<theNucleus.GetZ_asInt()<<G4endl<<G4endl; 
  G4int Bsum=thePrimary.GetDefinition()->GetBaryonNumber() + theNucleus.GetA_asInt();
  G4int Qsum=thePrimary.GetDefinition()->GetPDGCharge() + theNucleus.GetZ_asInt();
  G4cout<<"Initial baryon number "<<Bsum<<G4endl;
  G4cout<<"Initial charge        "<<Qsum<<G4endl;
  G4cout<<"-------------- Parton-String model:  Generation of strings -------"<<G4endl<<G4endl;
  Bsum -= theNucleus.GetA_asInt();  Qsum -= theNucleus.GetZ_asInt();
  if(GetProjectileNucleus()) {
    Bsum -= thePrimary.GetDefinition()->GetBaryonNumber();
    Qsum -= thePrimary.GetDefinition()->GetPDGCharge();
  }
  G4int QsumSec(0), BsumSec(0);
  G4LorentzVector SumPsecondr(0.,0.,0.,0.);
  #endif
 
  G4LorentzRotation toZ;
  G4LorentzVector Ptmp=thePrimary.Get4Momentum();
  toZ.rotateZ(-1*Ptmp.phi());
  toZ.rotateY(-1*Ptmp.theta());
  thePrimary.Set4Momentum(toZ*Ptmp);
  G4LorentzRotation toLab(toZ.inverse());
 
  G4bool Success=true;
  G4int attempts = 0, maxAttempts=1000;
  do
  {
    if (attempts++ > maxAttempts ) 
    {
      Init(theNucleus,thePrimary);  // To put a nucleus into ground state
                                             // But marks of hitted nucleons are left. They must be erased.
      G4V3DNucleus * ResNucleus = GetWoundedNucleus(); 
      theNuclNucleon = ResNucleus->StartLoop() ? ResNucleus->GetNextNucleon() : nullptr;
      while( theNuclNucleon )
      {
        if(theNuclNucleon->AreYouHit()) theNuclNucleon->Hit(nullptr);
        theNuclNucleon = ResNucleus->GetNextNucleon();
      }
 
      G4V3DNucleus * ProjResNucleus = GetProjectileNucleus();
      if(ProjResNucleus != 0)
      {
        theNuclNucleon = ProjResNucleus->StartLoop() ? ProjResNucleus->GetNextNucleon() : nullptr;
        while( theNuclNucleon )
        {
          if(theNuclNucleon->AreYouHit()) theNuclNucleon->Hit(nullptr);
          theNuclNucleon = ProjResNucleus->GetNextNucleon();
        }
      }
 
      G4ExceptionDescription ed;
      ed << "Projectile Name Mass " <<thePrimary.GetDefinition()->GetParticleName()
         << " " << thePrimary.GetMass()<< G4endl;
      ed << "           Momentum  " << thePrimary.Get4Momentum() <<G4endl;
      ed << "Target nucleus   A Z " << theNucleus.GetA_asInt() << " "
                                      << theNucleus.GetZ_asInt() <<G4endl;
      ed << "Initial states of projectile and target nucleus will be returned!"<<G4endl;
      G4Exception( "G4VPartonStringModel::Scatter(): fails to generate or fragment strings ",
                   "HAD_PARTON_STRING_001", JustWarning, ed );
 
      G4ThreeVector Position(0.,0.,2*ResNucleus->GetOuterRadius());
      G4KineticTrack* Hadron = new G4KineticTrack(aPrimary.GetParticleDefinition(), 0.,
                                                  Position, aPrimary.Get4Momentum());
      if(theResult == nullptr) theResult = new G4KineticTrackVector();
      theResult->push_back(Hadron);
      return theResult;
    }
 
    Success=true;
 
    Init(theNucleus,thePrimary);
 
    strings = GetStrings();
 
    if (strings->empty()) { Success=false; continue; }
 
    // G4double stringEnergy(0);
    SumStringMom=G4LorentzVector(0.,0.,0.,0.);
 
    #ifdef debug_PartonStringModel
    G4cout<<"------------ Parton-String model: Number of produced strings ---- "<<strings->size()<<G4endl;
    #endif
 
    #ifdef debug_heavyHadrons
    // Check charm and bottom numbers of the projectile:
    G4int count_charm_projectile  = thePrimary.GetDefinition()->GetQuarkContent( 4 ) -
                                    thePrimary.GetDefinition()->GetAntiQuarkContent( 4 );
    G4int count_bottom_projectile = thePrimary.GetDefinition()->GetQuarkContent( 5 ) -
                                    thePrimary.GetDefinition()->GetAntiQuarkContent( 5 );
    G4int count_charm_strings = 0, count_bottom_strings = 0;
    G4int count_charm_hadrons = 0, count_bottom_hadrons = 0;
    #endif
    
    for ( unsigned int astring=0; astring < strings->size(); astring++)
    {
      //    rotate string to lab frame, models have it aligned to z
      if((*strings)[astring]->IsExcited())
      {
        // stringEnergy += (*strings)[astring]->GetLeftParton()->Get4Momentum().t();
        // stringEnergy += (*strings)[astring]->GetRightParton()->Get4Momentum().t();
        (*strings)[astring]->LorentzRotate(toLab);
        SumStringMom+=(*strings)[astring]->Get4Momentum();
        #ifdef debug_PartonStringModel
        G4cout<<"String No "<<astring+1<<" "<<(*strings)[astring]->Get4Momentum()<<" "
                            <<(*strings)[astring]->Get4Momentum().mag()
              <<" Partons   "<<(*strings)[astring]->GetLeftParton()->GetDefinition()->GetPDGEncoding()
              <<"          "<<(*strings)[astring]->GetRightParton()->GetDefinition()->GetPDGEncoding()<<G4endl;
        #endif
 
        #ifdef debug_heavyHadrons
    G4int left_charm =      (*strings)[astring]->GetLeftParton()->GetDefinition()->GetQuarkContent( 4 );
    G4int left_anticharm =  (*strings)[astring]->GetLeftParton()->GetDefinition()->GetAntiQuarkContent( 4 );
    G4int right_charm =     (*strings)[astring]->GetRightParton()->GetDefinition()->GetQuarkContent( 4 );
    G4int right_anticharm = (*strings)[astring]->GetRightParton()->GetDefinition()->GetAntiQuarkContent( 4 );
    G4int left_bottom =      (*strings)[astring]->GetLeftParton()->GetDefinition()->GetQuarkContent( 5 );
    G4int left_antibottom =  (*strings)[astring]->GetLeftParton()->GetDefinition()->GetAntiQuarkContent( 5 );
    G4int right_bottom =     (*strings)[astring]->GetRightParton()->GetDefinition()->GetQuarkContent( 5 );
    G4int right_antibottom = (*strings)[astring]->GetRightParton()->GetDefinition()->GetAntiQuarkContent( 5 );
    if ( left_charm  != 0  ||  left_anticharm  != 0  ||  right_charm  != 0  ||  right_anticharm  != 0  ||
         left_bottom != 0  ||  left_antibottom != 0  ||  right_bottom != 0  ||  right_antibottom != 0 ) {
      count_charm_strings  += left_charm  - left_anticharm  + right_charm  - right_anticharm;
      count_bottom_strings += left_bottom - left_antibottom + right_bottom - right_antibottom;
      G4cout << "G4VPartonStringModel::Scatter : string #" << astring << " ("
         << (*strings)[astring]->GetLeftParton()->GetDefinition()->GetParticleName() << " , "
         << (*strings)[astring]->GetRightParton()->GetDefinition()->GetParticleName() << ")" << G4endl;
    }
        #endif  
      }
      else
      {
        // stringEnergy += (*strings)[astring]->GetKineticTrack()->Get4Momentum().t();
        (*strings)[astring]->LorentzRotate(toLab);
        SumStringMom+=(*strings)[astring]->GetKineticTrack()->Get4Momentum();
        #ifdef debug_PartonStringModel
        G4cout<<"A track No "<<astring+1<<" "
              <<(*strings)[astring]->GetKineticTrack()->Get4Momentum()<<" "
              <<(*strings)[astring]->GetKineticTrack()->Get4Momentum().mag()<<" "
              <<(*strings)[astring]->GetKineticTrack()->GetDefinition()->GetParticleName()<<G4endl;
        #endif
 
        #ifdef debug_heavyHadrons
    G4int charm =      (*strings)[astring]->GetKineticTrack()->GetDefinition()->GetQuarkContent( 4 );
    G4int anticharm =  (*strings)[astring]->GetKineticTrack()->GetDefinition()->GetAntiQuarkContent( 4 );
    G4int bottom =     (*strings)[astring]->GetKineticTrack()->GetDefinition()->GetQuarkContent( 5 );
    G4int antibottom = (*strings)[astring]->GetKineticTrack()->GetDefinition()->GetAntiQuarkContent( 5 );
        if ( charm != 0  ||  anticharm != 0  ||  bottom != 0  || antibottom != 0 ) {
      count_charm_strings +=  charm  - anticharm;
      count_bottom_strings += bottom - antibottom;
      G4cout << "G4VPartonStringModel::Scatter : track #" << astring << "\t"
                 << (*strings)[astring]->GetKineticTrack()->GetDefinition()->GetParticleName() << G4endl;
    }
        #endif
      }
    }
 
    #ifdef debug_heavyHadrons
    if ( count_charm_projectile != count_charm_strings ) {
      G4cout << "G4VPartonStringModel::Scatter : CHARM VIOLATION in String formation ! #projectile="
         << count_charm_projectile << " ; #strings=" << count_charm_strings << G4endl;
    }
    if ( count_bottom_projectile != count_bottom_strings ) {
      G4cout << "G4VPartonStringModel::Scatter : BOTTOM VIOLATION in String formation ! #projectile="
         << count_bottom_projectile << " ; #strings=" << count_bottom_strings << G4endl;
    }
    #endif
    
    #ifdef debug_PartonStringModel
    G4cout<<G4endl<<"SumString4Mom "<<SumStringMom<<G4endl;
    G4LorentzVector TargetResidual4Momentum(0.,0.,0.,0.);
    G4LorentzVector ProjectileResidual4Momentum(0.,0.,0.,0.);
    G4int hitsT(0), charged_hitsT(0);
    G4int hitsP(0), charged_hitsP(0);
    G4double ExcitationEt(0.), ExcitationEp(0.);
    #endif
 
    // We assume that the target nucleus is never a hypernucleus, whereas
    // the projectile nucleus can be a light hypernucleus or anti-hypernucleus.
    
    G4V3DNucleus * ProjResNucleus = GetProjectileNucleus();
 
    G4int numberProtonProjectileResidual( 0 ), numberNeutronProjectileResidual( 0 );
    G4int numberLambdaProjectileResidual( 0 );
    if(ProjResNucleus != 0)
    {
      theNuclNucleon = ProjResNucleus->StartLoop() ? ProjResNucleus->GetNextNucleon() : nullptr;
      G4int numberProtonProjectileHits( 0 ), numberNeutronProjectileHits( 0 );
      G4int numberLambdaProjectileHits( 0 );
      while( theNuclNucleon )
      {
        if(theNuclNucleon->AreYouHit())
        {
          G4LorentzVector tmp=toLab*theNuclNucleon->Get4Momentum();
      const G4ParticleDefinition* def = theNuclNucleon->GetDefinition();
          #ifdef debug_PartonStringModel
          ProjectileResidual4Momentum += tmp;
          hitsP++;
          if ( def == G4Proton::Definition() || def == G4AntiProton::Definition() ) ++charged_hitsP;
          ExcitationEp +=theNuclNucleon->GetBindingEnergy();
          #endif
          theNuclNucleon->SetMomentum(tmp);
          if ( def == G4Proton::Definition()  || def == G4AntiProton::Definition() )  ++numberProtonProjectileHits;
          if ( def == G4Neutron::Definition() || def == G4AntiNeutron::Definition() ) ++numberNeutronProjectileHits;
          if ( def == G4Lambda::Definition()  || def == G4AntiLambda::Definition() )  ++numberLambdaProjectileHits;
        }
        theNuclNucleon = ProjResNucleus->GetNextNucleon();
      }
      G4int numberLambdaProjectile = 0;
      if ( thePrimary.GetDefinition()->IsHypernucleus() ) {
    numberLambdaProjectile = thePrimary.GetDefinition()->GetNumberOfLambdasInHypernucleus();
      } else if ( thePrimary.GetDefinition()->IsAntiHypernucleus() ) {
    numberLambdaProjectile = thePrimary.GetDefinition()->GetNumberOfAntiLambdasInAntiHypernucleus();
      }
      #ifdef debug_PartonStringModel
      G4cout<<"Projectile residual A, Z (numberOfLambdasOrAntiLambdas) and E* "
            <<thePrimary.GetDefinition()->GetBaryonNumber() - hitsP<<" "
            <<thePrimary.GetDefinition()->GetPDGCharge()    - charged_hitsP<<" ("
        << numberLambdaProjectile - numberLambdaProjectileHits << ") "
            <<ExcitationEp<<G4endl;
      G4cout<<"Projectile residual 4 momentum  "<<ProjectileResidual4Momentum<<G4endl;
      #endif
      numberProtonProjectileResidual = std::max( std::abs( G4int( thePrimary.GetDefinition()->GetPDGCharge() ) ) -
                         numberProtonProjectileHits, 0 );
      numberLambdaProjectileResidual = std::max( numberLambdaProjectile - numberLambdaProjectileHits, 0 );
      numberNeutronProjectileResidual = std::max( std::abs( thePrimary.GetDefinition()->GetBaryonNumber() ) -
                                                  std::abs( G4int( thePrimary.GetDefinition()->GetPDGCharge() ) ) -
                          numberLambdaProjectile - numberNeutronProjectileHits, 0 );
    }
 
    G4V3DNucleus * ResNucleus = GetWoundedNucleus(); 
 
    // loop over wounded nucleus
    theNuclNucleon = ResNucleus->StartLoop() ? ResNucleus->GetNextNucleon() : nullptr;
    G4int numberProtonTargetHits( 0 ), numberNeutronTargetHits( 0 );
    while( theNuclNucleon )
    {
      if(theNuclNucleon->AreYouHit())
      {
        G4LorentzVector tmp=toLab*theNuclNucleon->Get4Momentum();
        #ifdef debug_PartonStringModel
        TargetResidual4Momentum += tmp;
        hitsT++;
        if ( theNuclNucleon->GetDefinition() == G4Proton::Proton() )  ++charged_hitsT;
        ExcitationEt +=theNuclNucleon->GetBindingEnergy();
        #endif
        theNuclNucleon->SetMomentum(tmp);
        if ( theNuclNucleon->GetDefinition() == G4Proton::Proton() )   ++numberProtonTargetHits;
        if ( theNuclNucleon->GetDefinition() == G4Neutron::Neutron() ) ++numberNeutronTargetHits;
      }
      theNuclNucleon = ResNucleus->GetNextNucleon();
    }
 
    #ifdef debug_PartonStringModel
    G4cout<<"Target residual A, Z and E* "
          <<theNucleus.GetA_asInt() - hitsT<<" "
          <<theNucleus.GetZ_asInt() - charged_hitsT<<" "
          <<ExcitationEt<<G4endl;
    G4cout<<"Target residual 4 momentum "<<TargetResidual4Momentum<<G4endl;
    Bsum+=(        hitsT +         hitsP);
    Qsum+=(charged_hitsT + charged_hitsP);
    G4cout<<"Hitted # of nucleons of projectile and target "<<hitsP<<" "<<hitsT<<G4endl;
    G4cout<<"Hitted # of protons of projectile and target  "
          <<charged_hitsP<<" "<<charged_hitsT<<G4endl<<G4endl;
    G4cout<<"Bsum Qsum "<<Bsum<<" "<<Qsum<<G4endl<<G4endl;
    #endif
 
    // Re-sample in the case of unphysical nuclear residual:
    // 1 (H), 2 (2He), and 3 (3Li) protons alone without neutrons can exist, but not more;
    // no bound states of 2 or more neutrons without protons can exist.
    G4int numberProtonTargetResidual = theNucleus.GetZ_asInt() - numberProtonTargetHits;
    G4int numberNeutronTargetResidual = theNucleus.GetA_asInt() - theNucleus.GetZ_asInt() - numberNeutronTargetHits;
    G4bool unphysicalResidual = false;
    if ( ( numberProtonTargetResidual > 3   &&  numberNeutronTargetResidual == 0 ) ||
         ( numberProtonTargetResidual == 0  &&  numberNeutronTargetResidual > 1  ) ) {
      unphysicalResidual = true;
      //G4cout << "***UNPHYSICAL TARGET RESIDUAL*** Z=" << numberProtonTargetResidual 
      //       << " ; N=" << numberNeutronTargetResidual;
    }
    // The projectile residual can be a hypernucleus or anti-hypernucleus:
    // only the following combinations are currently allowed in Geant4:
    // p-n-lambda (hypertriton), p-n-n-lambda (hyperH4), p-p-n-lambda (hyperAlpha),
    // p-p-n-n-lambda (hyperHe5), n-n-lambda-lambda (doublehyperdoubleneutron),
    // p-n-lambda-lambda (doubleHyperH4)
    if ( ( numberProtonProjectileResidual > 3   &&  numberNeutronProjectileResidual == 0 ) ||
         ( numberProtonProjectileResidual == 0  &&  numberNeutronProjectileResidual > 1  &&
       numberLambdaProjectileResidual == 0 ) ||
     ( numberProtonProjectileResidual == 0  &&  numberNeutronProjectileResidual <= 1  &&
       numberLambdaProjectileResidual > 0 ) ||
     ( numberProtonProjectileResidual == 0  &&  numberNeutronProjectileResidual > 2  &&
       numberLambdaProjectileResidual > 0 ) ||
     ( numberLambdaProjectileResidual > 2 ) ||
     ( numberProtonProjectileResidual > 0  &&  numberNeutronProjectileResidual == 0  &&
       numberLambdaProjectileResidual > 0 ) ||
     ( numberProtonProjectileResidual > 1  &&  numberNeutronProjectileResidual > 1  &&
       numberLambdaProjectileResidual > 1 )
     ) {
      unphysicalResidual = true;
      //G4cout << "***UNPHYSICAL PROJECTILE RESIDUAL*** Z=" << numberProtonProjectileResidual
      //       << " ; N=" << numberNeutronProjectileResidual;
    }
    if ( unphysicalResidual ) {
      //G4cout << " -> REJECTING COLLISION because of unphysical residual !" << G4endl;
      Success = false;
      continue;
    }
 
    //=========================================================================================
    //                              Fragment strings
    #ifdef debug_PartonStringModel
    G4cout<<"---------------- Attempt to fragment strings ------------- "<<attempts<<G4endl;
    #endif
 
    G4double InvMass=SumStringMom.mag();
    G4double SumMass(0.); 
 
    #ifdef debug_PartonStringModel
    QsumSec=0; BsumSec=0;
    SumPsecondr=G4LorentzVector(0.,0.,0.,0.);
    #endif
 
    if(theResult != nullptr)
    {
      std::for_each(theResult->begin(), theResult->end(), DeleteKineticTrack());
      delete theResult;
    }
 
    theResult = stringFragmentationModel->FragmentStrings(strings);
 
    #ifdef debug_PartonStringModel
    G4cout<<"String fragmentation success (OK - #0, Not OK - 0) : "<<theResult<<G4endl;
    #endif
 
    if(theResult == 0) {Success=false; continue;}
 
    #ifdef debug_PartonStringModel
    G4cout<<"Parton-String model: Number of produced particles "<<theResult->size()<<G4endl;
    SumPsecondr = G4LorentzVector(0.,0.,0.,0.);
    QsumSec = 0; BsumSec = 0;
    #endif
 
    SumMass=0.;
    for ( unsigned int i=0; i < theResult->size(); i++)
    {
      SumMass+=(*theResult)[i]->Get4Momentum().mag();
      #ifdef debug_PartonStringModel
      G4cout<<i<<" : "<<(*theResult)[i]->GetDefinition()->GetParticleName()<<" "
                      <<(*theResult)[i]->Get4Momentum()<<" "
                      <<(*theResult)[i]->Get4Momentum().mag()<<" "
                      <<(*theResult)[i]->GetDefinition()->GetPDGMass()<<G4endl;
      SumPsecondr+=(*theResult)[i]->Get4Momentum();
      BsumSec += (*theResult)[i]->GetDefinition()->GetBaryonNumber();
      QsumSec += (*theResult)[i]->GetDefinition()->GetPDGCharge();
      #endif
 
      #ifdef debug_heavyHadrons
      G4int charm =      (*theResult)[i]->GetDefinition()->GetQuarkContent( 4 );
      G4int anticharm =  (*theResult)[i]->GetDefinition()->GetAntiQuarkContent( 4 );
      G4int bottom =     (*theResult)[i]->GetDefinition()->GetQuarkContent( 5 );
      G4int antibottom = (*theResult)[i]->GetDefinition()->GetAntiQuarkContent( 5 );
      if ( charm != 0  ||  anticharm != 0  ||  bottom != 0  || antibottom != 0 ) {
        count_charm_hadrons +=  charm - anticharm;          
        count_bottom_hadrons += bottom - antibottom;
    G4cout << "G4VPartonStringModel::Scatter : hadron #" << i << "\t"
               << (*theResult)[i]->GetDefinition()->GetParticleName() << G4endl;
      }
      #endif  
    }
 
    #ifdef debug_heavyHadrons
    if ( count_charm_projectile != count_charm_hadrons ) {
      G4cout << "G4VPartonStringModel::Scatter : CHARM VIOLATION in String hadronization ! #projectile="
         << count_charm_projectile << " ; #hadrons=" << count_charm_hadrons << G4endl;
    }
    if ( count_bottom_projectile != count_bottom_hadrons ) {
      G4cout << "G4VPartonStringModel::Scatter : BOTTOM VIOLATION in String hadronization ! #projectile="
         << count_bottom_projectile << " ; #hadrons=" << count_bottom_hadrons << G4endl;
    }
    #endif
    
    #ifdef debug_PartonStringModel
    G4cout<<G4endl<<"-----------------------Parton-String model: balances -------------"<<G4endl;
    if(Qsum != QsumSec) {
      G4cout<<"Charge is not conserved!!! ----"<<G4endl; 
      G4cout<<" Qsum != QsumSec "<<Qsum<<" "<<QsumSec<<G4endl;
    }
    if(Bsum != BsumSec) {
      G4cout<<"Baryon number is not conserved!!!"<<G4endl;
      G4cout<<" Bsum != BsumSec "<<Bsum<<" "<<BsumSec<<G4endl;
    }
    #endif
 
    if((SumMass > InvMass)||(SumMass == 0.)) {Success=false;}
    std::for_each(strings->begin(), strings->end(), DeleteString() );
    delete strings;
 
  } while(!Success);
 
  #ifdef debug_PartonStringModel
  G4cout        <<"Baryon number balance "<<Bsum-BsumSec<<G4endl;
  G4cout        <<"Charge balance        "<<Qsum-QsumSec<<G4endl;
  G4cout        <<"4 momentum balance    "<<SumStringMom-SumPsecondr<<G4endl; 
  G4cout<<"---------------------End of Parton-String model work -------------"<<G4endl<<G4endl;
  #endif
 
  return theResult;
}

◆ SetBminBmax()

void G4FTFModel::SetBminBmax	(	const G4double	bmin_value,
		const G4double	bmax_value
	)

inline

Definition at line 232 of file G4FTFModel.hh.

                                                                                          {
  BinInterval = false;
  if ( bmin_value < 0.0 || bmax_value < 0.0 || bmax_value < bmin_value ) return;
  BinInterval = true;
  Bmin = bmin_value;
  Bmax = bmax_value;
}

References BinInterval, Bmax, and Bmin.

◆ SetEnergyMomentumCheckLevels()

void G4HadronicInteraction::SetEnergyMomentumCheckLevels	(	G4double	relativeLevel,
		G4double	absoluteLevel
	)

inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

150 { epCheckLevels.first = relativeLevel;

151 epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

Referenced by G4BinaryCascade::G4BinaryCascade(), G4CascadeInterface::G4CascadeInterface(), and G4FTFModel().

◆ SetFragmentationModel()

void G4VPartonStringModel::SetFragmentationModel ( G4VStringFragmentation * aModel )

inlineinherited

Definition at line 78 of file G4VPartonStringModel.hh.

{
  if(aModel != stringFragmentationModel) {
    stringFragmentationModel = aModel;
  }
}

References G4VPartonStringModel::stringFragmentationModel.

Referenced by G4BertiniElectroNuclearBuilder::Build(), G4FTFBuilder::BuildModel(), G4QGSBuilder::BuildModel(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4QGSBinaryKaonBuilder::G4QGSBinaryKaonBuilder(), G4QGSBinaryNeutronBuilder::G4QGSBinaryNeutronBuilder(), G4QGSBinaryPiKBuilder::G4QGSBinaryPiKBuilder(), G4QGSBinaryPionBuilder::G4QGSBinaryPionBuilder(), G4QGSBinaryProtonBuilder::G4QGSBinaryProtonBuilder(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4QGSPKaonBuilder::G4QGSPKaonBuilder(), G4QGSPLundStrFragmProtonBuilder::G4QGSPLundStrFragmProtonBuilder(), G4QGSPNeutronBuilder::G4QGSPNeutronBuilder(), G4QGSPPiKBuilder::G4QGSPPiKBuilder(), G4QGSPPionBuilder::G4QGSPPionBuilder(), and G4QGSPProtonBuilder::G4QGSPProtonBuilder().

◆ SetImpactParameter()

void G4FTFModel::SetImpactParameter ( const G4double b_value )

inline

Definition at line 224 of file G4FTFModel.hh.

                                                                   {
  Bimpact = b_value;
}

References Bimpact.

Referenced by GetStrings().

◆ SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double anEnergy )

inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

103 { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

◆ SetMaxEnergy() [2/3]

void G4HadronicInteraction::SetMaxEnergy	(	G4double	anEnergy,
		const G4Element *	anElement
	)

inherited

Definition at line 151 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyListElements.empty()) {
    for(auto & elmlist : theMaxEnergyListElements) {
      if( anElement == elmlist.second ) {
        elmlist.first = anEnergy;
        return;
      }
    }
  }
  theMaxEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyListElements.

◆ SetMaxEnergy() [3/3]

void G4HadronicInteraction::SetMaxEnergy	(	G4double	anEnergy,
		const G4Material *	aMaterial
	)

inherited

Definition at line 166 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMaxEnergyList.empty()) {
    for(auto & matlist: theMaxEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMaxEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMaxEnergyList.

◆ SetMinEnergy() [1/3]

void G4HadronicInteraction::SetMinEnergy ( G4double anEnergy )

inlineinherited

Definition at line 89 of file G4HadronicInteraction.hh.

90 { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

◆ SetMinEnergy() [2/3]

void G4HadronicInteraction::SetMinEnergy	(	G4double	anEnergy,
		const G4Element *	anElement
	)

inherited

Definition at line 101 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyListElements.empty()) {
    for(auto & elmlist : theMinEnergyListElements) {
      if( anElement == elmlist.second ) {
    elmlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyListElements.push_back(std::pair<G4double, const G4Element *>(anEnergy, anElement));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyListElements.

◆ SetMinEnergy() [3/3]

void G4HadronicInteraction::SetMinEnergy	(	G4double	anEnergy,
		const G4Material *	aMaterial
	)

inherited

Definition at line 116 of file G4HadronicInteraction.cc.

{
  Block(); 
  if(!theMinEnergyList.empty()) {
    for(auto & matlist : theMinEnergyList) {
      if( aMaterial == matlist.second ) {
    matlist.first = anEnergy;
    return;
      }
    }
  }
  theMinEnergyList.push_back(std::pair<G4double, const G4Material *>(anEnergy, aMaterial));
}

References G4HadronicInteraction::Block(), and G4HadronicInteraction::theMinEnergyList.

◆ SetModelName()

void G4HadronicInteraction::SetModelName ( const G4String & nam )

inlineprotectedinherited

Definition at line 166 of file G4HadronicInteraction.hh.

167 { theModelName = nam; }

References G4HadronicInteraction::theModelName.

Referenced by G4ExcitedStringDecay::G4ExcitedStringDecay().

◆ SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double val )

inlineinherited

Definition at line 138 of file G4HadronicInteraction.hh.

139 { recoilEnergyThreshold = val; }

References G4HadronicInteraction::recoilEnergyThreshold.

Referenced by G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

◆ SetVerboseLevel()

void G4HadronicInteraction::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 112 of file G4HadronicInteraction.hh.

113 { verboseLevel = value; }

References G4HadronicInteraction::verboseLevel.

Referenced by G4CascadeInterface::SetVerboseLevel(), and G4PreCompoundDeexcitation::setVerboseLevel().

◆ StoreInvolvedNucleon()

void G4FTFModel::StoreInvolvedNucleon ( )

private

Definition at line 405 of file G4FTFModel.cc.

                                      {
  //To store nucleons involved in the interaction
 
  NumberOfInvolvedNucleonsOfTarget = 0;
 
  G4V3DNucleus* theTargetNucleus = GetTargetNucleus();
  theTargetNucleus->StartLoop();
 
  G4Nucleon* aNucleon;
  while ( ( aNucleon = theTargetNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
    if ( aNucleon->AreYouHit() ) {
      TheInvolvedNucleonsOfTarget[NumberOfInvolvedNucleonsOfTarget] = aNucleon;
      NumberOfInvolvedNucleonsOfTarget++;
    }
  }
 
  #ifdef debugFTFmodel
  G4cout << "G4FTFModel::StoreInvolvedNucleon -------------" << G4endl;
  G4cout << "NumberOfInvolvedNucleonsOfTarget " << NumberOfInvolvedNucleonsOfTarget
         << G4endl << G4endl;
  #endif
 
 
  if ( ! GetProjectileNucleus() ) return;  // The projectile is a hadron
 
  // The projectile is a nucleus or an anti-nucleus.
 
  NumberOfInvolvedNucleonsOfProjectile = 0;
 
  G4V3DNucleus* theProjectileNucleus = GetProjectileNucleus();
  theProjectileNucleus->StartLoop();
 
  G4Nucleon* aProjectileNucleon;
  while ( ( aProjectileNucleon = theProjectileNucleus->GetNextNucleon() ) ) {  /* Loop checking, 10.08.2015, A.Ribon */
    if ( aProjectileNucleon->AreYouHit() ) {  
      // Projectile nucleon was involved in the interaction.
      TheInvolvedNucleonsOfProjectile[NumberOfInvolvedNucleonsOfProjectile] = aProjectileNucleon;
      NumberOfInvolvedNucleonsOfProjectile++;
    }
  } 
 
  #ifdef debugFTFmodel
  G4cout << "NumberOfInvolvedNucleonsOfProjectile " << NumberOfInvolvedNucleonsOfProjectile
         << G4endl << G4endl;
  #endif
  return;
}                        

References G4Nucleon::AreYouHit(), G4cout, G4endl, G4V3DNucleus::GetNextNucleon(), GetProjectileNucleus(), GetTargetNucleus(), NumberOfInvolvedNucleonsOfProjectile, NumberOfInvolvedNucleonsOfTarget, G4V3DNucleus::StartLoop(), TheInvolvedNucleonsOfProjectile, and TheInvolvedNucleonsOfTarget.

Referenced by GetStrings().

Field Documentation

◆ Bimpact

G4double G4FTFModel::Bimpact

private

Definition at line 203 of file G4FTFModel.hh.

Referenced by G4FTFModel(), GetImpactParameter(), and SetImpactParameter().

◆ BinInterval

G4bool G4FTFModel::BinInterval

private

Definition at line 204 of file G4FTFModel.hh.

Referenced by G4FTFModel(), SampleBinInterval(), and SetBminBmax().

◆ Bmax

G4double G4FTFModel::Bmax

private

Definition at line 206 of file G4FTFModel.hh.

Referenced by G4FTFModel(), GetBmax(), and SetBminBmax().

◆ Bmin

G4double G4FTFModel::Bmin

private

Definition at line 205 of file G4FTFModel.hh.

Referenced by G4FTFModel(), GetBmin(), and SetBminBmax().

◆ epCheckLevels

std::pair<G4double, G4double> G4HadronicInteraction::epCheckLevels

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetEnergyMomentumCheckLevels(), and G4HadronicInteraction::SetEnergyMomentumCheckLevels().

◆ HighEnergyInter

G4bool G4FTFModel::HighEnergyInter

private

Definition at line 190 of file G4FTFModel.hh.

Referenced by BuildStrings(), ExciteParticipants(), G4FTFModel(), GetResiduals(), GetStrings(), and Init().

◆ isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::Block(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4HadronicInteraction::IsBlocked().

◆ LowEnergyLimit

G4double G4FTFModel::LowEnergyLimit

private

Definition at line 189 of file G4FTFModel.hh.

Referenced by G4FTFModel(), and Init().

◆ NumberOfInvolvedNucleonsOfProjectile

G4int G4FTFModel::NumberOfInvolvedNucleonsOfProjectile

private

Definition at line 180 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetResiduals(), GetStrings(), PutOnMassShell(), ReggeonCascade(), StoreInvolvedNucleon(), and ~G4FTFModel().

◆ NumberOfInvolvedNucleonsOfTarget

G4int G4FTFModel::NumberOfInvolvedNucleonsOfTarget

private

Definition at line 177 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetResiduals(), GetStrings(), PutOnMassShell(), ReggeonCascade(), StoreInvolvedNucleon(), and ~G4FTFModel().

◆ NumberOfNNcollisions

G4int G4FTFModel::NumberOfNNcollisions

private

Definition at line 209 of file G4FTFModel.hh.

Referenced by ExciteParticipants(), G4FTFModel(), GetNumberOfNNcollisions(), and Init().

◆ NumberOfProjectileSpectatorNucleons

G4int G4FTFModel::NumberOfProjectileSpectatorNucleons

private

Definition at line 207 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetNumberOfProjectileSpectatorNucleons(), and Init().

◆ NumberOfTargetSpectatorNucleons

G4int G4FTFModel::NumberOfTargetSpectatorNucleons

private

Definition at line 208 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetNumberOfTargetSpectatorNucleons(), and Init().

◆ ProjectileResidual4Momentum

G4LorentzVector G4FTFModel::ProjectileResidual4Momentum

private

Definition at line 192 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ ProjectileResidualCharge

G4int G4FTFModel::ProjectileResidualCharge

private

Definition at line 194 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ ProjectileResidualExcitationEnergy

G4double G4FTFModel::ProjectileResidualExcitationEnergy

private

Definition at line 196 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ ProjectileResidualLambdaNumber

G4int G4FTFModel::ProjectileResidualLambdaNumber

private

Definition at line 195 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), and Init().

◆ ProjectileResidualMassNumber

G4int G4FTFModel::ProjectileResidualMassNumber

private

Definition at line 193 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), AdjustNucleonsAlgorithm_Sampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ recoilEnergyThreshold

G4double G4HadronicInteraction::recoilEnergyThreshold

privateinherited

Definition at line 194 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetRecoilEnergyThreshold(), and G4HadronicInteraction::SetRecoilEnergyThreshold().

◆ registry

G4HadronicInteractionRegistry* G4HadronicInteraction::registry

privateinherited

Definition at line 192 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::G4HadronicInteraction(), and G4HadronicInteraction::~G4HadronicInteraction().

◆ stringFragmentationModel

G4VStringFragmentation* G4VPartonStringModel::stringFragmentationModel

privateinherited

Definition at line 75 of file G4VPartonStringModel.hh.

Referenced by G4VPartonStringModel::Scatter(), and G4VPartonStringModel::SetFragmentationModel().

◆ TargetResidual4Momentum

G4LorentzVector G4FTFModel::TargetResidual4Momentum

private

Definition at line 198 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ TargetResidualCharge

G4int G4FTFModel::TargetResidualCharge

private

Definition at line 200 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ TargetResidualExcitationEnergy

G4double G4FTFModel::TargetResidualExcitationEnergy

private

Definition at line 201 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ TargetResidualMassNumber

G4int G4FTFModel::TargetResidualMassNumber

private

Definition at line 199 of file G4FTFModel.hh.

Referenced by AdjustNucleons(), AdjustNucleonsAlgorithm_afterSampling(), AdjustNucleonsAlgorithm_beforeSampling(), AdjustNucleonsAlgorithm_Sampling(), G4FTFModel(), GetResiduals(), Init(), and PutOnMassShell().

◆ theAdditionalString

std::vector< G4VSplitableHadron* > G4FTFModel::theAdditionalString

private

Definition at line 187 of file G4FTFModel.hh.

Referenced by BuildStrings(), ExciteParticipants(), Init(), and ~G4FTFModel().

◆ theAnnihilation

G4FTFAnnihilation* G4FTFModel::theAnnihilation

private

Definition at line 185 of file G4FTFModel.hh.

Referenced by ExciteParticipants(), and ~G4FTFModel().

◆ theBlockedList

std::vector<const G4Material *> G4HadronicInteraction::theBlockedList

privateinherited

Definition at line 204 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

◆ theBlockedListElements

std::vector<const G4Element *> G4HadronicInteraction::theBlockedListElements

privateinherited

Definition at line 205 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::DeActivateFor(), and G4HadronicInteraction::IsBlocked().

◆ theElastic

G4ElasticHNScattering* G4FTFModel::theElastic

private

Definition at line 184 of file G4FTFModel.hh.

Referenced by ExciteParticipants(), and ~G4FTFModel().

◆ theExcitation

G4DiffractiveExcitation* G4FTFModel::theExcitation

private

Definition at line 183 of file G4FTFModel.hh.

Referenced by BuildStrings(), ExciteParticipants(), and ~G4FTFModel().

◆ TheInvolvedNucleonsOfProjectile

G4Nucleon* G4FTFModel::TheInvolvedNucleonsOfProjectile[250]

private

Definition at line 179 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetResiduals(), GetStrings(), PutOnMassShell(), ReggeonCascade(), StoreInvolvedNucleon(), and ~G4FTFModel().

◆ TheInvolvedNucleonsOfTarget

G4Nucleon* G4FTFModel::TheInvolvedNucleonsOfTarget[250]

private

Definition at line 176 of file G4FTFModel.hh.

Referenced by BuildStrings(), G4FTFModel(), GetResiduals(), GetStrings(), PutOnMassShell(), ReggeonCascade(), StoreInvolvedNucleon(), and ~G4FTFModel().

◆ theMaxEnergy

G4double G4HadronicInteraction::theMaxEnergy

protectedinherited

Definition at line 186 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4HadronicInteraction::G4HadronicInteraction(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMaxEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMaxEnergyList

privateinherited

Definition at line 201 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMaxEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMaxEnergyListElements

privateinherited

Definition at line 203 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMaxEnergy(), and G4HadronicInteraction::SetMaxEnergy().

◆ theMinEnergy

G4double G4HadronicInteraction::theMinEnergy

protectedinherited

Definition at line 185 of file G4HadronicInteraction.hh.

Referenced by G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theMinEnergyList

std::vector<std::pair<G4double, const G4Material *> > G4HadronicInteraction::theMinEnergyList

privateinherited

Definition at line 200 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theMinEnergyListElements

std::vector<std::pair<G4double, const G4Element *> > G4HadronicInteraction::theMinEnergyListElements

privateinherited

Definition at line 202 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetMinEnergy(), and G4HadronicInteraction::SetMinEnergy().

◆ theModelName

G4String G4HadronicInteraction::theModelName

privateinherited

Definition at line 196 of file G4HadronicInteraction.hh.

Referenced by G4HadronicInteraction::GetModelName(), and G4HadronicInteraction::SetModelName().

◆ theParameters

G4FTFParameters* G4FTFModel::theParameters

private

Definition at line 182 of file G4FTFModel.hh.

Referenced by AdjustNucleonsAlgorithm_beforeSampling(), AdjustNucleonsAlgorithm_Sampling(), BuildStrings(), ComputeNucleusProperties(), ExciteParticipants(), G4FTFModel(), GetStrings(), Init(), PutOnMassShell(), ReggeonCascade(), and ~G4FTFModel().

◆ theParticipants

G4FTFParticipants G4FTFModel::theParticipants

private

Definition at line 174 of file G4FTFModel.hh.

Referenced by BuildStrings(), ExciteParticipants(), GetProjectileNucleus(), GetStrings(), GetTargetNucleus(), GetWoundedNucleus(), Init(), and PutOnMassShell().

◆ theParticleChange

G4HadFinalState G4HadronicInteraction::theParticleChange

protectedinherited

Definition at line 172 of file G4HadronicInteraction.hh.

◆ theProjectile

G4ReactionProduct G4FTFModel::theProjectile

private

Definition at line 173 of file G4FTFModel.hh.

Referenced by GetStrings(), Init(), PutOnMassShell(), and ReggeonCascade().

◆ verboseLevel

G4int G4HadronicInteraction::verboseLevel

protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

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

source/processes/hadronic/models/parton_string/diffraction/include/G4FTFModel.hh
source/processes/hadronic/models/parton_string/diffraction/src/G4FTFModel.cc

Data Structures

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4FTFModel() [1/2]

◆ ~G4FTFModel()

◆ G4FTFModel() [2/2]

Member Function Documentation

◆ ActivateFor() [1/2]

◆ ActivateFor() [2/2]

◆ AdjustNucleons()

◆ AdjustNucleonsAlgorithm_afterSampling()

◆ AdjustNucleonsAlgorithm_beforeSampling()

◆ AdjustNucleonsAlgorithm_Sampling()

◆ ApplyYourself()

◆ Block()

◆ BuildPhysicsTable()

◆ BuildStrings()

◆ CheckKinematics()

◆ ComputeNucleusProperties()

◆ DeActivateFor() [1/2]

◆ DeActivateFor() [2/2]

◆ EnergyAndMomentumCorrector()

◆ ExciteParticipants()

◆ FinalizeKinematics()

◆ GaussianPt()

◆ GenerateDeltaIsobar()

◆ GetBmax()

◆ GetBmin()

◆ GetEnergyMomentumCheckLevels()

◆ GetFatalEnergyCheckLevels()

◆ GetImpactParameter()

◆ GetMaxEnergy() [1/2]

◆ GetMaxEnergy() [2/2]

◆ GetMinEnergy() [1/2]

◆ GetMinEnergy() [2/2]

◆ GetModelName()

◆ GetNumberOfNNcollisions()

◆ GetNumberOfProjectileSpectatorNucleons()

◆ GetNumberOfTargetSpectatorNucleons()

◆ GetProjectileNucleus()

◆ GetRecoilEnergyThreshold()

◆ GetResiduals()

◆ GetStrings()

◆ GetTargetNucleus()

◆ GetVerboseLevel()

◆ GetWoundedNucleus()

◆ Init()

◆ InitialiseModel()

◆ IsApplicable()

◆ IsBlocked() [1/3]

◆ IsBlocked() [2/3]

◆ IsBlocked() [3/3]

◆ ModelDescription()

◆ operator!=() [1/4]

◆ operator!=() [2/4]

◆ operator!=() [3/4]

◆ operator!=() [4/4]

◆ operator=()

◆ operator==() [1/4]

◆ operator==() [2/4]

◆ operator==() [3/4]

◆ operator==() [4/4]

◆ PutOnMassShell()

◆ ReggeonCascade()

◆ SampleBinInterval()

◆ SampleInvariantT()

◆ SamplingNucleonKinematics()

◆ Scatter()

◆ SetBminBmax()

◆ SetEnergyMomentumCheckLevels()

◆ SetFragmentationModel()

◆ SetImpactParameter()

◆ SetMaxEnergy() [1/3]

◆ SetMaxEnergy() [2/3]

◆ SetMaxEnergy() [3/3]