G4INCLXXInterface Class Reference

INCL++ intra-nuclear cascade. More...

#include <G4INCLXXInterface.hh>

Inheritance diagram for G4INCLXXInterface:

Public Member Functions
void	ActivateFor (const G4Element *anElement)
void	ActivateFor (const G4Material *aMaterial)
G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &theNucleus)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DeActivateFor (const G4Element *anElement)
void	DeActivateFor (const G4Material *aMaterial)
void	DeleteModel ()
	G4INCLXXInterface (G4VPreCompoundModel *const aPreCompound=0)
G4String const &	GetDeExcitationModelName () const
virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
virtual const std::pair< G4double, G4double >	GetFatalEnergyCheckLevels () 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
G4double	GetRecoilEnergyThreshold () const
G4int	GetVerboseLevel () const
virtual void	InitialiseModel ()
virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
G4bool	IsBlocked (const G4Element *anElement) const
G4bool	IsBlocked (const G4Material *aMaterial) const
virtual void	ModelDescription (std::ostream &outFile) const
G4bool	operator!= (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4VIntraNuclearTransportModel &right) const =delete
G4bool	operator!= (G4INCLXXInterface &right)
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator== (const G4VIntraNuclearTransportModel &right) const =delete
G4bool	operator== (G4INCLXXInterface &right)
G4ReactionProductVector *	Propagate (G4KineticTrackVector *theSecondaries, G4V3DNucleus *theNucleus)
virtual void	PropagateModelDescription (std::ostream &outFile) const
virtual G4ReactionProductVector *	PropagateNuclNucl (G4KineticTrackVector *theSecondaries, G4V3DNucleus *theNucleus, G4V3DNucleus *theProjectileNucleus)
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
void	Set3DNucleus (G4V3DNucleus *const value)
void	SetDeExcitation (G4VPreCompoundModel *ptr)
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
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	SetPrimaryProjectile (const G4HadProjectile &aPrimary)
void	SetRecoilEnergyThreshold (G4double val)
void	SetVerboseLevel (G4int value)
	~G4INCLXXInterface ()

Protected Member Functions
void	Block ()
G4V3DNucleus *	Get3DNucleus () const
G4VPreCompoundModel *	GetDeExcitation () const
const G4HadProjectile *	GetPrimaryProjectile () const
G4bool	IsBlocked () const
void	SetModelName (const G4String &nam)

Protected Attributes
G4bool	isBlocked
G4V3DNucleus *	the3DNucleus
G4VPreCompoundModel *	theDeExcitation
G4double	theMaxEnergy
G4double	theMinEnergy
G4HadFinalState	theParticleChange
const G4HadProjectile *	thePrimaryProjectile
G4String	theTransportModelName
G4int	verboseLevel

Private Member Functions
G4bool	AccurateProjectile (const G4HadProjectile &aTrack, const G4Nucleus &theTargetNucleus) const
	G4INCLXXInterface (const G4INCLXXInterface &rhs)
	Dummy copy constructor to shut up Coverity warnings. More...
G4INCLXXInterface &	operator= (G4INCLXXInterface const &rhs)
	Dummy assignment operator to shut up Coverity warnings. More...
G4double	remnant4MomentumScaling (G4double mass, G4double kineticE, G4double px, G4double py, G4double pz) const
	Rescale remnant momentum if necessary. More...
G4DynamicParticle *	toG4Particle (G4int A, G4int Z, G4int S, G4int PDGCode, G4double kinE, G4double px, G4double py, G4double pz) const
	Convert an INCL particle to a G4DynamicParticle. More...
G4ParticleDefinition *	toG4ParticleDefinition (G4int A, G4int Z, G4int S, G4int PDGCode) const
	Convert A, Z and S to a G4ParticleDefinition. More...
G4double	toINCLKineticEnergy (G4HadProjectile const &) const
	Convert G4HadProjectile to corresponding INCL particle kinetic energy. More...
G4INCL::ParticleSpecies	toINCLParticleSpecies (G4HadProjectile const &) const
	Convert G4HadProjectile to corresponding INCL particle species. More...
G4INCL::ParticleType	toINCLParticleType (G4ParticleDefinition const *const) const
	Convert G4ParticleDefinition to corresponding INCL particle type. More...

Private Attributes
G4bool	complainedAboutBackupModel
G4bool	complainedAboutPreCompound
G4bool	dumpRemnantInfo
std::pair< G4double, G4double >	epCheckLevels
G4double	recoilEnergyThreshold
G4HadronicInteractionRegistry *	registry
G4int	secID
G4HadronicInteraction *	theBackupModel
G4HadronicInteraction *	theBackupModelNucleon
std::vector< const G4Material * >	theBlockedList
std::vector< const G4Element * >	theBlockedListElements
G4INCL::INCL *	theINCLModel
G4FissionProbability *	theINCLXXFissionProbability
G4VLevelDensityParameter *	theINCLXXLevelDensity
G4INCLXXInterfaceStore *const	theInterfaceStore
G4IonTable *const	theIonTable
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
G4VPreCompoundModel *	thePreCompoundModel
G4HadFinalState	theResult
G4INCLXXVInterfaceTally *	theTally

Detailed Description

INCL++ intra-nuclear cascade.

Interface for INCL++. This interface handles basic hadron bullet particles (protons, neutrons, pions), as well as light ions.

Example usage in case of protons:

G4INCLXXInterface* inclModel = new G4INCLXXInterface;
inclModel -> SetMinEnergy(0.0 * MeV); // Set the energy limits
inclModel -> SetMaxEnergy(3.0 * GeV);
 
G4HadronInelasticProcess* protonInelasticProcess = new G4HadronInelasticProcess( "protonInelastic", G4Proton::Definition() );
G4VCrossSectionDataSet* protonInelasticCrossSection = new G4BGGNucleonInelasticXS( G4Proton::Proton() );
 
protonInelasticProcess -> RegisterMe(inclModel);
protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
 
particle = G4Proton::Proton();
processManager = particle -> GetProcessManager();
processManager -> AddDiscreteProcess(protonInelasticProcess);

The same setup procedure is needed for neutron, pion and generic-ion inelastic processes as well.

Definition at line 103 of file G4INCLXXInterface.hh.

Constructor & Destructor Documentation

G4INCLXXInterface() [1/2]

G4INCLXXInterface::G4INCLXXInterface

(

G4VPreCompoundModel *const

aPreCompound = 0

)

Definition at line 68 of file G4INCLXXInterface.cc.

                                                                             :
  G4VIntraNuclearTransportModel(G4INCLXXInterfaceStore::GetInstance()->getINCLXXVersionName()),
  theINCLModel(NULL),
  thePreCompoundModel(aPreCompound),
  theInterfaceStore(G4INCLXXInterfaceStore::GetInstance()),
  theTally(NULL),
  complainedAboutBackupModel(false),
  complainedAboutPreCompound(false),
  theIonTable(G4IonTable::GetIonTable()),
  theINCLXXLevelDensity(NULL),
  theINCLXXFissionProbability(NULL),
  secID(-1)
{
  if(!thePreCompoundModel) {
    G4HadronicInteraction* p =
      G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
    thePreCompoundModel = static_cast<G4VPreCompoundModel*>(p);
    if(!thePreCompoundModel) { thePreCompoundModel = new G4PreCompoundModel; }
  }
 
  // Use the environment variable G4INCLXX_NO_DE_EXCITATION to disable de-excitation
  if(std::getenv("G4INCLXX_NO_DE_EXCITATION")) {
    G4String message = "de-excitation is completely disabled!";
    theInterfaceStore->EmitWarning(message);
    theDeExcitation = 0;
  } else {
    G4HadronicInteraction* p =
      G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
    theDeExcitation = static_cast<G4VPreCompoundModel*>(p);
    if(!theDeExcitation) { theDeExcitation = new G4PreCompoundModel; }
 
    // set the fission parameters for G4ExcitationHandler
    G4VEvaporationChannel * const theFissionChannel =
      theDeExcitation->GetExcitationHandler()->GetEvaporation()->GetFissionChannel();
    G4CompetitiveFission * const theFissionChannelCast = dynamic_cast<G4CompetitiveFission *>(theFissionChannel);
    if(theFissionChannelCast) {
      theINCLXXLevelDensity = new G4FissionLevelDensityParameterINCLXX;
      theFissionChannelCast->SetLevelDensityParameter(theINCLXXLevelDensity);
      theINCLXXFissionProbability = new G4FissionProbability;
      theINCLXXFissionProbability->SetFissionLevelDensityParameter(theINCLXXLevelDensity);
      theFissionChannelCast->SetEmissionStrategy(theINCLXXFissionProbability);
      theInterfaceStore->EmitBigWarning("INCL++/G4ExcitationHandler uses its own level-density parameter for fission");
    } else {
      theInterfaceStore->EmitBigWarning("INCL++/G4ExcitationHandler could not use its own level-density parameter for fission");
    }
  }
 
  // use the envvar G4INCLXX_DUMP_REMNANT to dump information about the
  // remnants on stdout
  if(std::getenv("G4INCLXX_DUMP_REMNANT"))
    dumpRemnantInfo = true;
  else
    dumpRemnantInfo = false;
 
  theBackupModel = new G4BinaryLightIonReaction;
  theBackupModelNucleon = new G4BinaryCascade;
  secID = G4PhysicsModelCatalog::GetModelID( "model_INCLXXCascade" );
}

References dumpRemnantInfo, G4INCLXXInterfaceStore::EmitBigWarning(), G4INCLXXInterfaceStore::EmitWarning(), G4HadronicInteractionRegistry::FindModel(), G4ExcitationHandler::GetEvaporation(), G4VPreCompoundModel::GetExcitationHandler(), G4VEvaporation::GetFissionChannel(), G4PhysicsModelCatalog::GetModelID(), G4HadronicInteractionRegistry::Instance(), secID, G4CompetitiveFission::SetEmissionStrategy(), G4FissionProbability::SetFissionLevelDensityParameter(), G4CompetitiveFission::SetLevelDensityParameter(), theBackupModel, theBackupModelNucleon, G4VIntraNuclearTransportModel::theDeExcitation, theINCLXXFissionProbability, theINCLXXLevelDensity, theInterfaceStore, and thePreCompoundModel.

~G4INCLXXInterface()

G4INCLXXInterface::~G4INCLXXInterface

(

)

Definition at line 127 of file G4INCLXXInterface.cc.

{
  delete theINCLXXLevelDensity;
  delete theINCLXXFissionProbability;
}

References theINCLXXFissionProbability, and theINCLXXLevelDensity.

G4INCLXXInterface() [2/2]

G4INCLXXInterface::G4INCLXXInterface ( const G4INCLXXInterface &  rhs )

private

Dummy copy constructor to shut up Coverity warnings.

Member Function Documentation

AccurateProjectile()

G4bool G4INCLXXInterface::AccurateProjectile ( const G4HadProjectile &  aTrack, const G4Nucleus &  theTargetNucleus  ) const

private

Definition at line 133 of file G4INCLXXInterface.cc.

                                                                                                             {
  // Use direct kinematics if the projectile is a nucleon or a pion
  const G4ParticleDefinition *projectileDef = aTrack.GetDefinition();
  if(std::abs(projectileDef->GetBaryonNumber()) < 2) // Every non-composite particle. abs()-> in case of anti-nucleus projectile
    return false;
 
  // Here all projectiles should be nuclei
  const G4int pA = projectileDef->GetAtomicMass();
  if(pA<=0) {
    std::stringstream ss;
    ss << "the model does not know how to handle a collision between a "
      << projectileDef->GetParticleName() << " projectile and a Z="
      << theNucleus.GetZ_asInt() << ", A=" << theNucleus.GetA_asInt();
    theInterfaceStore->EmitBigWarning(ss.str());
    return true;
  }
 
  // If either nucleus is a LCP (A<=4), run the collision as light on heavy
  const G4int tA = theNucleus.GetA_asInt();
  if(tA<=4 || pA<=4) {
    if(pA<tA)
      return false;
    else
      return true;
  }
 
  // If one of the nuclei is heavier than theMaxProjMassINCL, run the collision
  // as light on heavy.
  // Note that here we are sure that either the projectile or the target is
  // smaller than theMaxProjMass; otherwise theBackupModel would have been
  // called.
  const G4int theMaxProjMassINCL = theInterfaceStore->GetMaxProjMassINCL();
  if(pA > theMaxProjMassINCL)
    return true;
  else if(tA > theMaxProjMassINCL)
    return false;
  else
    // In all other cases, use the global setting
    return theInterfaceStore->GetAccurateProjectile();
}

References G4INCLXXInterfaceStore::EmitBigWarning(), G4Nucleus::GetA_asInt(), G4INCLXXInterfaceStore::GetAccurateProjectile(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetBaryonNumber(), G4HadProjectile::GetDefinition(), G4INCLXXInterfaceStore::GetMaxProjMassINCL(), G4ParticleDefinition::GetParticleName(), G4Nucleus::GetZ_asInt(), and theInterfaceStore.

Referenced by ApplyYourself().

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().

ApplyYourself()

G4HadFinalState * G4INCLXXInterface::ApplyYourself ( const G4HadProjectile &  aTrack, G4Nucleus &  theNucleus  )

virtual

Main method to apply the INCL physics model.

Parameters

aTrack	the projectile particle
theNucleus	target nucleus

Returns

the output of the INCL physics model

Reimplemented from G4HadronicInteraction.

Definition at line 174 of file G4INCLXXInterface.cc.

{
  G4ParticleDefinition const * const trackDefinition = aTrack.GetDefinition();
  const G4bool isIonTrack = trackDefinition->GetParticleType()==G4GenericIon::GenericIon()->GetParticleType();
  const G4int trackA = trackDefinition->GetAtomicMass();
  const G4int trackZ = (G4int) trackDefinition->GetPDGCharge();
  const G4int trackL = trackDefinition->GetNumberOfLambdasInHypernucleus();
  const G4int nucleusA = theNucleus.GetA_asInt();
  const G4int nucleusZ = theNucleus.GetZ_asInt();
 
  // For reactions induced by weird projectiles (e.g. He2), bail out
  if((isIonTrack && ((trackZ<=0 && trackL==0) || trackA<=trackZ)) ||
                    (nucleusA>1 && (nucleusZ<=0 || nucleusA<=nucleusZ))) {
    theResult.Clear();
    theResult.SetStatusChange(isAlive);
    theResult.SetEnergyChange(aTrack.GetKineticEnergy());
    theResult.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
    return &theResult;
  }
 
  // For reactions on nucleons, use the backup model (without complaining)
  if(trackA<=1 && nucleusA<=1) {
    return theBackupModelNucleon->ApplyYourself(aTrack, theNucleus);
  }
 
  // For systems heavier than theMaxProjMassINCL, use another model (typically
  // BIC)
  const G4int theMaxProjMassINCL = theInterfaceStore->GetMaxProjMassINCL();
  if(trackA > theMaxProjMassINCL && nucleusA > theMaxProjMassINCL) {
    if(!complainedAboutBackupModel) {
      complainedAboutBackupModel = true;
      std::stringstream ss;
      ss << "INCL++ refuses to handle reactions between nuclei with A>"
        << theMaxProjMassINCL
        << ". A backup model ("
        << theBackupModel->GetModelName()
        << ") will be used instead.";
      theInterfaceStore->EmitBigWarning(ss.str());
    }
    return theBackupModel->ApplyYourself(aTrack, theNucleus);
  }
 
  // For energies lower than cascadeMinEnergyPerNucleon, use PreCompound
  const G4double cascadeMinEnergyPerNucleon = theInterfaceStore->GetCascadeMinEnergyPerNucleon();
  const G4double trackKinE = aTrack.GetKineticEnergy();
  if((trackDefinition==G4Neutron::NeutronDefinition() || trackDefinition==G4Proton::ProtonDefinition())
      && trackKinE < cascadeMinEnergyPerNucleon) {
    if(!complainedAboutPreCompound) {
      complainedAboutPreCompound = true;
      std::stringstream ss;
      ss << "INCL++ refuses to handle nucleon-induced reactions below "
        << cascadeMinEnergyPerNucleon / MeV
        << " MeV. A PreCoumpound model ("
        << thePreCompoundModel->GetModelName()
        << ") will be used instead.";
      theInterfaceStore->EmitBigWarning(ss.str());
    }
    return thePreCompoundModel->ApplyYourself(aTrack, theNucleus);
  }
 
  // Calculate the total four-momentum in the entrance channel
  const G4double theNucleusMass = theIonTable->GetIonMass(nucleusZ, nucleusA);
  const G4double theTrackMass = trackDefinition->GetPDGMass();
  const G4double theTrackEnergy = trackKinE + theTrackMass;
  const G4double theTrackMomentumAbs2 = theTrackEnergy*theTrackEnergy - theTrackMass*theTrackMass;
  const G4double theTrackMomentumAbs = ((theTrackMomentumAbs2>0.0) ? std::sqrt(theTrackMomentumAbs2) : 0.0);
  const G4ThreeVector theTrackMomentum = aTrack.Get4Momentum().getV().unit() * theTrackMomentumAbs;
 
  G4LorentzVector goodTrack4Momentum(theTrackMomentum, theTrackEnergy);
  G4LorentzVector fourMomentumIn;
  fourMomentumIn.setE(theTrackEnergy + theNucleusMass);
  fourMomentumIn.setVect(theTrackMomentum);
 
  // Check if inverse kinematics should be used
  const G4bool inverseKinematics = AccurateProjectile(aTrack, theNucleus);
 
  // If we are running in inverse kinematics, redefine aTrack and theNucleus
  G4LorentzRotation *toInverseKinematics = NULL;
  G4LorentzRotation *toDirectKinematics = NULL;
  G4HadProjectile const *aProjectileTrack = &aTrack;
  G4Nucleus *theTargetNucleus = &theNucleus;
  if(inverseKinematics) {
    G4ParticleDefinition *oldTargetDef = theIonTable->GetIon(nucleusZ, nucleusA, 0);
    const G4ParticleDefinition *oldProjectileDef = trackDefinition;
 
    if(oldProjectileDef != 0 && oldTargetDef != 0) {
      const G4int newTargetA = oldProjectileDef->GetAtomicMass();
      const G4int newTargetZ = oldProjectileDef->GetAtomicNumber();
      const G4int newTargetL = oldProjectileDef->GetNumberOfLambdasInHypernucleus();
      if(newTargetA > 0 && newTargetZ > 0) {
        // This should give us the same energy per nucleon
        theTargetNucleus = new G4Nucleus(newTargetA, newTargetZ, newTargetL);
        toInverseKinematics = new G4LorentzRotation(goodTrack4Momentum.boostVector());
        G4LorentzVector theProjectile4Momentum(0.0, 0.0, 0.0, theNucleusMass);
        G4DynamicParticle swappedProjectileParticle(oldTargetDef, (*toInverseKinematics) * theProjectile4Momentum);
        aProjectileTrack = new G4HadProjectile(swappedProjectileParticle);
      } else {
        G4String message = "badly defined target after swapping. Falling back to normal (non-swapped) mode.";
        theInterfaceStore->EmitWarning(message);
        toInverseKinematics = new G4LorentzRotation;
      }
    } else {
      G4String message = "oldProjectileDef or oldTargetDef was null";
      theInterfaceStore->EmitWarning(message);
      toInverseKinematics = new G4LorentzRotation;
    }
  }
 
  // INCL assumes the projectile particle is going in the direction of
  // the Z-axis. Here we construct proper rotation to convert the
  // momentum vectors of the outcoming particles to the original
  // coordinate system.
  G4LorentzVector projectileMomentum = aProjectileTrack->Get4Momentum();
 
  // INCL++ assumes that the projectile is going in the direction of
  // the z-axis. In principle, if the coordinate system used by G4
  // hadronic framework is defined differently we need a rotation to
  // transform the INCL++ reaction products to the appropriate
  // frame. Please note that it isn't necessary to apply this
  // transform to the projectile because when creating the INCL++
  // projectile particle; \see{toINCLKineticEnergy} needs to use only the
  // projectile energy (direction is simply assumed to be along z-axis).
  G4RotationMatrix toZ;
  toZ.rotateZ(-projectileMomentum.phi());
  toZ.rotateY(-projectileMomentum.theta());
  G4RotationMatrix toLabFrame3 = toZ.inverse();
  G4LorentzRotation toLabFrame(toLabFrame3);
  // However, it turns out that the projectile given to us by G4
  // hadronic framework is already going in the direction of the
  // z-axis so this rotation is actually unnecessary. Both toZ and
  // toLabFrame turn out to be unit matrices as can be seen by
  // uncommenting the folowing two lines:
  // G4cout <<"toZ = " << toZ << G4endl;
  // G4cout <<"toLabFrame = " << toLabFrame << G4endl;
 
  theResult.Clear(); // Make sure the output data structure is clean.
  theResult.SetStatusChange(stopAndKill);
 
  std::list<G4Fragment> remnants;
 
  const G4int maxTries = 200;
  G4int nTries = 0;
  // INCL can generate transparent events. However, this is meaningful
  // only in the standalone code. In Geant4 we must "force" INCL to
  // produce a valid cascade.
  G4bool eventIsOK = false;
  do {
    const G4INCL::ParticleSpecies theSpecies = toINCLParticleSpecies(*aProjectileTrack);
    const G4double kineticEnergy = toINCLKineticEnergy(*aProjectileTrack);
 
    // The INCL model will be created at the first use
    theINCLModel = G4INCLXXInterfaceStore::GetInstance()->GetINCLModel();
 
    const G4INCL::EventInfo eventInfo = theINCLModel->processEvent(theSpecies, kineticEnergy,
                                   theTargetNucleus->GetA_asInt(),
                                   theTargetNucleus->GetZ_asInt(),
                                   -theTargetNucleus->GetL());  // Strangeness has opposite sign
    //    eventIsOK = !eventInfo.transparent && nTries < maxTries;                              // of the number of Lambdas 
    eventIsOK = !eventInfo.transparent;
    if(eventIsOK) {
 
      // If the collision was run in inverse kinematics, prepare to boost back
      // all the reaction products
      if(inverseKinematics) {
        toDirectKinematics = new G4LorentzRotation(toInverseKinematics->inverse());
      }
 
      G4LorentzVector fourMomentumOut;
 
      for(G4int i = 0; i < eventInfo.nParticles; ++i) {
    G4int A = eventInfo.A[i];
        G4int Z = eventInfo.Z[i];
    G4int S = eventInfo.S[i];  // Strangeness
        G4int PDGCode = eventInfo.PDGCode[i];
    //  G4cout <<"INCL particle A = " << A << " Z = " << Z << " S = " << S << G4endl;
    G4double kinE = eventInfo.EKin[i];
    G4double px = eventInfo.px[i];
    G4double py = eventInfo.py[i];
    G4double pz = eventInfo.pz[i];
    G4DynamicParticle *p = toG4Particle(A, Z, S, PDGCode, kinE, px, py, pz);
    if(p != 0) {
      G4LorentzVector momentum = p->Get4Momentum();
 
          // Apply the toLabFrame rotation
          momentum *= toLabFrame;
          // Apply the inverse-kinematics boost
          if(inverseKinematics) {
            momentum *= *toDirectKinematics;
            momentum.setVect(-momentum.vect());
          }
 
      // Set the four-momentum of the reaction products
      p->Set4Momentum(momentum);
          fourMomentumOut += momentum;
      theResult.AddSecondary(p, secID);
 
    } else {
      G4String message = "the model produced a particle that couldn't be converted to Geant4 particle.";
          theInterfaceStore->EmitWarning(message);
    }
      }
 
      for(G4int i = 0; i < eventInfo.nRemnants; ++i) {
    const G4int A = eventInfo.ARem[i];
    const G4int Z = eventInfo.ZRem[i];
    const G4int S = eventInfo.SRem[i];
    //  G4cout <<"INCL particle A = " << A << " Z = " << Z << " S= " << S << G4endl;
    const G4double kinE = eventInfo.EKinRem[i];
    const G4double px = eventInfo.pxRem[i];
    const G4double py = eventInfo.pyRem[i];
    const G4double pz = eventInfo.pzRem[i];
        G4ThreeVector spin(
            eventInfo.jxRem[i]*hbar_Planck,
            eventInfo.jyRem[i]*hbar_Planck,
            eventInfo.jzRem[i]*hbar_Planck
            );
    const G4double excitationE = eventInfo.EStarRem[i];
    G4double nuclearMass = excitationE;
    if ( S == 0 ) {
      nuclearMass += G4NucleiProperties::GetNuclearMass(A, Z);
    } else {
      // Assumed that the opposite of the strangeness of the remnant gives the number of Lambdas inside it
      nuclearMass += G4HyperNucleiProperties::GetNuclearMass(A, Z, std::abs(S));
    }
        const G4double scaling = remnant4MomentumScaling(nuclearMass, kinE, px, py, pz);
    G4LorentzVector fourMomentum(scaling * px, scaling * py, scaling * pz,
                     nuclearMass + kinE);
    if(std::abs(scaling - 1.0) > 0.01) {
          std::stringstream ss;
          ss << "momentum scaling = " << scaling
             << "\n                Lorentz vector = " << fourMomentum
         << ")\n                A = " << A << ", Z = " << Z << ", S = " << S
             << "\n                E* = " << excitationE << ", nuclearMass = " << nuclearMass
             << "\n                remnant i=" << i << ", nRemnants=" << eventInfo.nRemnants
             << "\n                Reaction was: " << aTrack.GetKineticEnergy()/MeV
             << "-MeV " << trackDefinition->GetParticleName() << " + "
             << theIonTable->GetIonName(theNucleus.GetZ_asInt(), theNucleus.GetA_asInt(), 0)
             << ", in " << (inverseKinematics ? "inverse" : "direct") << " kinematics.";
          theInterfaceStore->EmitWarning(ss.str());
    }
 
        // Apply the toLabFrame rotation
        fourMomentum *= toLabFrame;
        spin *= toLabFrame3;
        // Apply the inverse-kinematics boost
        if(inverseKinematics) {
          fourMomentum *= *toDirectKinematics;
          fourMomentum.setVect(-fourMomentum.vect());
        }
 
        fourMomentumOut += fourMomentum;
    G4Fragment remnant(A, Z, std::abs(S), fourMomentum);  // Assumed that -strangeness gives the number of Lambdas
        remnant.SetAngularMomentum(spin);
    remnant.SetCreatorModelID(secID);
        if(dumpRemnantInfo) {
          G4cerr << "G4INCLXX_DUMP_REMNANT: " << remnant << "  spin: " << spin << G4endl;
        }
    remnants.push_back(remnant);
      }
 
      // Check four-momentum conservation
      const G4LorentzVector violation4Momentum = fourMomentumOut - fourMomentumIn;
      const G4double energyViolation = std::abs(violation4Momentum.e());
      const G4double momentumViolation = violation4Momentum.rho();
      if(energyViolation > G4INCLXXInterfaceStore::GetInstance()->GetConservationTolerance()) {
        std::stringstream ss;
        ss << "energy conservation violated by " << energyViolation/MeV << " MeV in "
          << aTrack.GetKineticEnergy()/MeV << "-MeV " << trackDefinition->GetParticleName()
          << " + " << theIonTable->GetIonName(theNucleus.GetZ_asInt(), theNucleus.GetA_asInt(), 0)
          << " inelastic reaction, in " << (inverseKinematics ? "inverse" : "direct") << " kinematics. Will resample.";
        theInterfaceStore->EmitWarning(ss.str());
        eventIsOK = false;
        const G4int nSecondaries = theResult.GetNumberOfSecondaries();
        for(G4int j=0; j<nSecondaries; ++j)
          delete theResult.GetSecondary(j)->GetParticle();
        theResult.Clear();
        theResult.SetStatusChange(stopAndKill);
        remnants.clear();
      } else if(momentumViolation > G4INCLXXInterfaceStore::GetInstance()->GetConservationTolerance()) {
        std::stringstream ss;
        ss << "momentum conservation violated by " << momentumViolation/MeV << " MeV in "
          << aTrack.GetKineticEnergy()/MeV << "-MeV " << trackDefinition->GetParticleName()
          << " + " << theIonTable->GetIonName(theNucleus.GetZ_asInt(), theNucleus.GetA_asInt(), 0)
          << " inelastic reaction, in " << (inverseKinematics ? "inverse" : "direct") << " kinematics. Will resample.";
        theInterfaceStore->EmitWarning(ss.str());
        eventIsOK = false;
        const G4int nSecondaries = theResult.GetNumberOfSecondaries();
        for(G4int j=0; j<nSecondaries; ++j)
          delete theResult.GetSecondary(j)->GetParticle();
        theResult.Clear();
        theResult.SetStatusChange(stopAndKill);
        remnants.clear();
      }
    }
    nTries++;
  } while(!eventIsOK && nTries < maxTries); /* Loop checking, 10.07.2015, D.Mancusi */
 
  // Clean up the objects that we created for the inverse kinematics
  if(inverseKinematics) {
    delete aProjectileTrack;
    delete theTargetNucleus;
    delete toInverseKinematics;
    delete toDirectKinematics;
  }
 
  if(!eventIsOK) {
    std::stringstream ss;
    ss << "maximum number of tries exceeded for the proposed "
    << aTrack.GetKineticEnergy()/MeV << "-MeV " << trackDefinition->GetParticleName()
    << " + " << theIonTable->GetIonName(nucleusZ, nucleusA, 0)
    << " inelastic reaction, in " << (inverseKinematics ? "inverse" : "direct") << " kinematics.";
    theInterfaceStore->EmitWarning(ss.str());
    theResult.SetStatusChange(isAlive);
    theResult.SetEnergyChange(aTrack.GetKineticEnergy());
    theResult.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
    return &theResult;
  }
 
  // De-excitation:
 
  if(theDeExcitation != 0) {
    for(std::list<G4Fragment>::iterator i = remnants.begin();
    i != remnants.end(); ++i) {
      G4ReactionProductVector *deExcitationResult = theDeExcitation->DeExcite((*i));
 
      for(G4ReactionProductVector::iterator fragment = deExcitationResult->begin();
      fragment != deExcitationResult->end(); ++fragment) {
    const G4ParticleDefinition *def = (*fragment)->GetDefinition();
    if(def != 0) {
      G4DynamicParticle *theFragment = new G4DynamicParticle(def, (*fragment)->GetMomentum());
      theResult.AddSecondary(theFragment, (*fragment)->GetCreatorModelID());
    }
      }
 
      for(G4ReactionProductVector::iterator fragment = deExcitationResult->begin();
      fragment != deExcitationResult->end(); ++fragment) {
    delete (*fragment);
      }
      deExcitationResult->clear();
      delete deExcitationResult;
    }
  }
 
  remnants.clear();
 
  if((theTally = theInterfaceStore->GetTally()))
    theTally->Tally(aTrack, theNucleus, theResult);
 
  return &theResult;
}

References A, G4INCL::EventInfo::A, AccurateProjectile(), G4HadFinalState::AddSecondary(), G4HadronicInteraction::ApplyYourself(), G4INCL::EventInfo::ARem, CLHEP::HepLorentzVector::boostVector(), G4HadFinalState::Clear(), complainedAboutBackupModel, complainedAboutPreCompound, G4VPreCompoundModel::DeExcite(), dumpRemnantInfo, CLHEP::HepLorentzVector::e(), G4INCL::EventInfo::EKin, G4INCL::EventInfo::EKinRem, G4INCLXXInterfaceStore::EmitBigWarning(), G4INCLXXInterfaceStore::EmitWarning(), G4INCL::EventInfo::EStarRem, G4cerr, G4endl, G4GenericIon::GenericIon(), G4DynamicParticle::Get4Momentum(), G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4INCLXXInterfaceStore::GetCascadeMinEnergyPerNucleon(), G4INCLXXInterfaceStore::GetConservationTolerance(), G4HadProjectile::GetDefinition(), G4INCLXXInterfaceStore::GetINCLModel(), G4INCLXXInterfaceStore::GetInstance(), G4IonTable::GetIon(), G4IonTable::GetIonMass(), G4IonTable::GetIonName(), G4HadProjectile::GetKineticEnergy(), G4Nucleus::GetL(), G4INCLXXInterfaceStore::GetMaxProjMassINCL(), G4HadronicInteraction::GetModelName(), G4NucleiProperties::GetNuclearMass(), G4HyperNucleiProperties::GetNuclearMass(), G4ParticleDefinition::GetNumberOfLambdasInHypernucleus(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4HadFinalState::GetSecondary(), G4INCLXXInterfaceStore::GetTally(), CLHEP::HepLorentzVector::getV(), G4Nucleus::GetZ_asInt(), source.hepunit::hbar_Planck, CLHEP::HepLorentzRotation::inverse(), CLHEP::HepRotation::inverse(), isAlive, G4INCL::EventInfo::jxRem, G4INCL::EventInfo::jyRem, G4INCL::EventInfo::jzRem, MeV, G4Neutron::NeutronDefinition(), G4INCL::EventInfo::nParticles, G4INCL::EventInfo::nRemnants, G4INCL::EventInfo::PDGCode, CLHEP::HepLorentzVector::phi(), G4INCL::INCL::processEvent(), G4Proton::ProtonDefinition(), G4INCL::EventInfo::px, G4INCL::EventInfo::pxRem, G4INCL::EventInfo::py, G4INCL::EventInfo::pyRem, G4INCL::EventInfo::pz, G4INCL::EventInfo::pzRem, remnant4MomentumScaling(), CLHEP::HepLorentzVector::rho(), CLHEP::HepRotation::rotateY(), CLHEP::HepRotation::rotateZ(), S(), G4INCL::EventInfo::S, secID, G4DynamicParticle::Set4Momentum(), G4Fragment::SetAngularMomentum(), G4Fragment::SetCreatorModelID(), CLHEP::HepLorentzVector::setE(), G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetMomentumChange(), G4HadFinalState::SetStatusChange(), CLHEP::HepLorentzVector::setVect(), G4INCL::EventInfo::SRem, stopAndKill, G4INCLXXVInterfaceTally::Tally(), theBackupModel, theBackupModelNucleon, G4VIntraNuclearTransportModel::theDeExcitation, theINCLModel, theInterfaceStore, theIonTable, thePreCompoundModel, theResult, CLHEP::HepLorentzVector::theta(), theTally, toG4Particle(), toINCLKineticEnergy(), toINCLParticleSpecies(), G4INCL::EventInfo::transparent, CLHEP::Hep3Vector::unit(), CLHEP::HepLorentzVector::vect(), Z, G4INCL::EventInfo::Z, and G4INCL::EventInfo::ZRem.

Block()

void G4HadronicInteraction::Block ( )

inlineprotectedinherited

Definition at line 170 of file G4HadronicInteraction.hh.

{ isBlocked = true; }

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.

{}

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().

DeleteModel()

void G4INCLXXInterface::DeleteModel ( )

inline

Definition at line 128 of file G4INCLXXInterface.hh.

                     {
    delete theINCLModel;
    theINCLModel = NULL;
  }

References theINCLModel.

Get3DNucleus()

G4V3DNucleus * G4VIntraNuclearTransportModel::Get3DNucleus ( ) const

inlineprotectedinherited

Definition at line 119 of file G4VIntraNuclearTransportModel.hh.

{
  return the3DNucleus;
}

References G4VIntraNuclearTransportModel::the3DNucleus.

GetDeExcitation()

G4VPreCompoundModel * G4VIntraNuclearTransportModel::GetDeExcitation ( ) const

inlineprotectedinherited

Definition at line 129 of file G4VIntraNuclearTransportModel.hh.

{
  return theDeExcitation;
}

References G4VIntraNuclearTransportModel::theDeExcitation.

Referenced by G4BinaryCascade::G4BinaryCascade().

GetDeExcitationModelName()

G4String const & G4INCLXXInterface::GetDeExcitationModelName

(

)

const

Definition at line 646 of file G4INCLXXInterface.cc.

                                                                  {
  return theDeExcitation->GetModelName();
}

References G4HadronicInteraction::GetModelName(), and G4VIntraNuclearTransportModel::theDeExcitation.

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().

GetMaxEnergy() [1/2]

G4double G4HadronicInteraction::GetMaxEnergy ( ) const

inlineinherited

Definition at line 96 of file G4HadronicInteraction.hh.

  { return theMaxEnergy; }

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.

  { return theMinEnergy; }

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 & G4VIntraNuclearTransportModel::GetModelName ( ) const

inlineinherited

Definition at line 114 of file G4VIntraNuclearTransportModel.hh.

{
  return theTransportModelName;
}

References G4VIntraNuclearTransportModel::theTransportModelName.

GetPrimaryProjectile()

const G4HadProjectile * G4VIntraNuclearTransportModel::GetPrimaryProjectile ( ) const

inlineprotectedinherited

Definition at line 142 of file G4VIntraNuclearTransportModel.hh.

{
  return thePrimaryProjectile;
}

References G4VIntraNuclearTransportModel::thePrimaryProjectile.

Referenced by G4BinaryCascade::BuildLateParticleCollisions(), G4GeneratorPrecompoundInterface::Propagate(), G4CascadeInterface::Propagate(), and G4GeneratorPrecompoundInterface::PropagateNuclNucl().

GetRecoilEnergyThreshold()

G4double G4HadronicInteraction::GetRecoilEnergyThreshold ( ) const

inlineinherited

Definition at line 141 of file G4HadronicInteraction.hh.

  { return recoilEnergyThreshold;}

References G4HadronicInteraction::recoilEnergyThreshold.

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

GetVerboseLevel()

G4int G4HadronicInteraction::GetVerboseLevel ( ) const

inlineinherited

Definition at line 109 of file G4HadronicInteraction.hh.

  { return verboseLevel; }

References G4HadronicInteraction::verboseLevel.

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.

{}

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.

{ 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 G4INCLXXInterface::ModelDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 631 of file G4INCLXXInterface.cc.

                                                                  {
   outFile
     << "The Li�ge Intranuclear Cascade (INCL++) is a model for reactions induced\n"
     << "by nucleons, pions and light ion on any nucleus. The reaction is\n"
     << "described as an avalanche of binary nucleon-nucleon collisions, which can\n"
     << "lead to the emission of energetic particles and to the formation of an\n"
     << "excited thermalised nucleus (remnant). The de-excitation of the remnant is\n"
     << "outside the scope of INCL++ and is typically described by another model.\n\n"
     << "INCL++ has been reasonably well tested for nucleon (~50 MeV to ~15 GeV),\n"
     << "pion (idem) and light-ion projectiles (up to A=18, ~10A MeV to 1A GeV).\n"
     << "Most tests involved target nuclei close to the stability valley, with\n"
     << "numbers between 4 and 250.\n\n"
     << "Reference: D. Mancusi et al., Phys. Rev. C90 (2014) 054602\n\n";
}

operator!=() [1/3]

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

deleteinherited

operator!=() [2/3]

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

deleteinherited

operator!=() [3/3]

G4bool G4INCLXXInterface::operator!= ( G4INCLXXInterface &  right )

inline

Definition at line 112 of file G4INCLXXInterface.hh.

                                              {
    return (this != &right);
  }

operator=()

G4INCLXXInterface & G4INCLXXInterface::operator= ( G4INCLXXInterface const &  rhs )

private

Dummy assignment operator to shut up Coverity warnings.

operator==() [1/3]

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

deleteinherited

operator==() [2/3]

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

deleteinherited

operator==() [3/3]

G4bool G4INCLXXInterface::operator== ( G4INCLXXInterface &  right )

inline

Definition at line 108 of file G4INCLXXInterface.hh.

                                              {
    return (this == &right);
  }

Propagate()

G4ReactionProductVector * G4INCLXXInterface::Propagate ( G4KineticTrackVector *  theSecondaries, G4V3DNucleus *  theNucleus  )

virtual

Implements G4VIntraNuclearTransportModel.

Definition at line 525 of file G4INCLXXInterface.cc.

                                                                                            {
  return 0;
}

PropagateModelDescription()

void G4VIntraNuclearTransportModel::PropagateModelDescription ( std::ostream &  outFile ) const

virtualinherited

Reimplemented in G4BinaryCascade, and G4GeneratorPrecompoundInterface.

Definition at line 58 of file G4VIntraNuclearTransportModel.cc.

{
  outFile << "G4VIntraNuclearTransportModel is abstract class, missing description.\n";
}

Referenced by G4TheoFSGenerator::ModelDescription().

PropagateNuclNucl()

G4ReactionProductVector * G4VIntraNuclearTransportModel::PropagateNuclNucl ( G4KineticTrackVector *  theSecondaries, G4V3DNucleus *  theNucleus, G4V3DNucleus *  theProjectileNucleus  )

virtualinherited

Reimplemented in G4GeneratorPrecompoundInterface.

Definition at line 64 of file G4VIntraNuclearTransportModel.cc.

{
  G4Exception("G4VIntraNuclearTransportModel::Propagate()","G4VINT02",
              FatalException,
              "Propagate method for nucleus-nucleus interactions not implemented");
  return nullptr;
}

References FatalException, and G4Exception().

Referenced by G4TheoFSGenerator::ApplyYourself().

remnant4MomentumScaling()

G4double G4INCLXXInterface::remnant4MomentumScaling ( G4double  mass, G4double  kineticE, G4double  px, G4double  py, G4double  pz  ) const

private

Rescale remnant momentum if necessary.

Definition at line 618 of file G4INCLXXInterface.cc.

                                             {
  const G4double p2 = px*px + py*py + pz*pz;
  if(p2 > 0.0) {
    const G4double pnew2 = kineticE*kineticE + 2.0*kineticE*mass;
    return std::sqrt(pnew2)/std::sqrt(p2);
  } else {
    return 1.0;
  }
}

Referenced by ApplyYourself().

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;
}

Set3DNucleus()

void G4VIntraNuclearTransportModel::Set3DNucleus ( G4V3DNucleus *const  value )

inlineinherited

Definition at line 124 of file G4VIntraNuclearTransportModel.hh.

{
  delete the3DNucleus;  the3DNucleus = value;
}

References G4VIntraNuclearTransportModel::the3DNucleus.

SetDeExcitation()

void G4VIntraNuclearTransportModel::SetDeExcitation ( G4VPreCompoundModel *  ptr )

inline

Definition at line 81 of file G4VIntraNuclearTransportModel.hh.

{
  // previous pre-compound model will be deleted at the end of job 
  theDeExcitation = value;
}

Referenced by G4INCLXXInterfaceStore::UseAblaDeExcitation().

SetEnergyMomentumCheckLevels()

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

inlineinherited

Definition at line 149 of file G4HadronicInteraction.hh.

  { epCheckLevels.first = relativeLevel;
    epCheckLevels.second = absoluteLevel; }

References G4HadronicInteraction::epCheckLevels.

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

SetMaxEnergy() [1/3]

void G4HadronicInteraction::SetMaxEnergy ( const G4double  anEnergy )

inlineinherited

Definition at line 102 of file G4HadronicInteraction.hh.

  { theMaxEnergy = anEnergy; }

References G4HadronicInteraction::theMaxEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4IonINCLXXPhysics::AddProcess(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

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.

  { theMinEnergy = anEnergy; }

References G4HadronicInteraction::theMinEnergy.

Referenced by G4HadronicInteraction::ActivateFor(), G4BertiniElectroNuclearBuilder::Build(), G4LENDBertiniGammaElectroNuclearBuilder::Build(), G4NeutronLENDBuilder::Build(), G4NeutronPHPBuilder::Build(), G4AlphaPHPBuilder::Build(), G4BertiniKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryAlphaBuilder::Build(), G4BinaryDeuteronBuilder::Build(), G4BinaryHe3Builder::Build(), G4BinaryNeutronBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4BinaryProtonBuilder::Build(), G4BinaryTritonBuilder::Build(), G4DeuteronPHPBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4FTFPKaonBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4FTFPPiKBuilder::Build(), G4FTFPPionBuilder::Build(), G4FTFPProtonBuilder::Build(), G4He3PHPBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonQGSPBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4INCLXXPionBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4PrecoProtonBuilder::Build(), G4ProtonPHPBuilder::Build(), G4QGSBinaryKaonBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSBinaryPionBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSPAntiBarionBuilder::Build(), G4QGSPKaonBuilder::Build(), G4QGSPLundStrFragmProtonBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4TritonPHPBuilder::Build(), G4QGSPProtonBuilder::Build(), G4QGSBuilder::BuildModel(), G4VHadronPhysics::BuildModel(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), LBE::ConstructHad(), G4EmExtraPhysics::ConstructLENDGammaNuclear(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsPHP::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4IonINCLXXPhysics::ConstructProcess(), G4IonPhysics::ConstructProcess(), G4IonPhysicsPHP::ConstructProcess(), G4IonQMDPhysics::ConstructProcess(), G4ANuElNucleusNcModel::G4ANuElNucleusNcModel(), G4ANuMuNucleusNcModel::G4ANuMuNucleusNcModel(), G4BertiniKaonBuilder::G4BertiniKaonBuilder(), G4BertiniPiKBuilder::G4BertiniPiKBuilder(), G4BertiniPionBuilder::G4BertiniPionBuilder(), G4BinaryCascade::G4BinaryCascade(), G4BinaryPiKBuilder::G4BinaryPiKBuilder(), G4BinaryPionBuilder::G4BinaryPionBuilder(), G4ChargeExchange::G4ChargeExchange(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4EMDissociation::G4EMDissociation(), G4FissLib::G4FissLib(), G4FTFBinaryKaonBuilder::G4FTFBinaryKaonBuilder(), G4FTFBinaryNeutronBuilder::G4FTFBinaryNeutronBuilder(), G4FTFBinaryPiKBuilder::G4FTFBinaryPiKBuilder(), G4FTFBinaryPionBuilder::G4FTFBinaryPionBuilder(), G4FTFBinaryProtonBuilder::G4FTFBinaryProtonBuilder(), G4FTFPAntiBarionBuilder::G4FTFPAntiBarionBuilder(), G4FTFPKaonBuilder::G4FTFPKaonBuilder(), G4FTFPNeutronBuilder::G4FTFPNeutronBuilder(), G4FTFPPiKBuilder::G4FTFPPiKBuilder(), G4FTFPPionBuilder::G4FTFPPionBuilder(), G4FTFPProtonBuilder::G4FTFPProtonBuilder(), G4HadronElastic::G4HadronElastic(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), G4HadronicAbsorptionFritiofWithBinaryCascade::G4HadronicAbsorptionFritiofWithBinaryCascade(), G4hhElastic::G4hhElastic(), G4HyperonFTFPBuilder::G4HyperonFTFPBuilder(), G4HyperonQGSPBuilder::G4HyperonQGSPBuilder(), G4INCLXXPionBuilder::G4INCLXXPionBuilder(), G4LEHadronProtonElastic::G4LEHadronProtonElastic(), G4LENDModel::G4LENDModel(), G4LEnp::G4LEnp(), G4LEpp::G4LEpp(), G4LFission::G4LFission(), G4LowEGammaNuclearModel::G4LowEGammaNuclearModel(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), G4NeutrinoElectronCcModel::G4NeutrinoElectronCcModel(), G4NeutrinoElectronNcModel::G4NeutrinoElectronNcModel(), G4NeutrinoNucleusModel::G4NeutrinoNucleusModel(), G4NeutronElectronElModel::G4NeutronElectronElModel(), G4NeutronRadCapture::G4NeutronRadCapture(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4NuElNucleusNcModel::G4NuElNucleusNcModel(), G4NuMuNucleusNcModel::G4NuMuNucleusNcModel(), G4ParticleHPCapture::G4ParticleHPCapture(), G4ParticleHPElastic::G4ParticleHPElastic(), G4ParticleHPFission::G4ParticleHPFission(), G4ParticleHPInelastic::G4ParticleHPInelastic(), G4ParticleHPThermalScattering::G4ParticleHPThermalScattering(), G4QGSPAntiBarionBuilder::G4QGSPAntiBarionBuilder(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4NeutrinoElectronCcModel::IsApplicable(), G4HadronPhysicsFTFP_BERT_HP::Neutron(), G4HadronPhysicsINCLXX::Neutron(), G4HadronPhysicsQGSP_BERT_HP::Neutron(), G4HadronPhysicsQGSP_BIC_HP::Neutron(), G4HadronPhysicsShielding::Neutron(), and G4VHadronPhysics::NewModel().

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.

  { theModelName = nam; }

References G4HadronicInteraction::theModelName.

Referenced by G4ExcitedStringDecay::G4ExcitedStringDecay().

SetPrimaryProjectile()

void G4VIntraNuclearTransportModel::SetPrimaryProjectile ( const G4HadProjectile &  aPrimary )

inlineinherited

Definition at line 148 of file G4VIntraNuclearTransportModel.hh.

{
  // NOTE:  Previous pointer is NOT deleted: passed by reference, no ownership
  thePrimaryProjectile = &aPrimary;
}

References G4VIntraNuclearTransportModel::thePrimaryProjectile.

Referenced by G4TheoFSGenerator::ApplyYourself().

SetRecoilEnergyThreshold()

void G4HadronicInteraction::SetRecoilEnergyThreshold ( G4double  val )

inlineinherited

Definition at line 138 of file G4HadronicInteraction.hh.

  { 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.

  { verboseLevel = value; }

References G4HadronicInteraction::verboseLevel.

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

toG4Particle()

G4DynamicParticle * G4INCLXXInterface::toG4Particle ( G4int  A, G4int  Z, G4int  S, G4int  PDGCode, G4double  kinE, G4double  px, G4double  py, G4double  pz  ) const

private

Convert an INCL particle to a G4DynamicParticle.

Definition at line 604 of file G4INCLXXInterface.cc.

                                                                                   {
  const G4ParticleDefinition *def = toG4ParticleDefinition(A, Z, S, PDGCode);
  if(def == 0) { // Check if we have a valid particle definition
    return 0;
  }
  const G4double energy = kinE * MeV;
  const G4ThreeVector momentum(px, py, pz);
  const G4ThreeVector momentumDirection = momentum.unit();
  G4DynamicParticle *p = new G4DynamicParticle(def, momentumDirection, energy);
  return p;
}

References A, G4INCL::KinematicsUtils::energy(), MeV, S(), toG4ParticleDefinition(), CLHEP::Hep3Vector::unit(), and Z.

Referenced by ApplyYourself().

toG4ParticleDefinition()

G4ParticleDefinition * G4INCLXXInterface::toG4ParticleDefinition ( G4int  A, G4int  Z, G4int  S, G4int  PDGCode  ) const

private

Convert A, Z and S to a G4ParticleDefinition.

Definition at line 568 of file G4INCLXXInterface.cc.

                                                                                                              {
  if       (PDGCode == 2212) { return G4Proton::Proton();
  } else if(PDGCode == 2112) { return G4Neutron::Neutron();
  } else if(PDGCode == 211)  { return G4PionPlus::PionPlus();
  } else if(PDGCode == 111)  { return G4PionZero::PionZero();
  } else if(PDGCode == -211) { return G4PionMinus::PionMinus();
  
  } else if(PDGCode == 221)  { return G4Eta::Eta();
  } else if(PDGCode == 22)   { return G4Gamma::Gamma();
  
  } else if(PDGCode == 3122) { return G4Lambda::Lambda();
  } else if(PDGCode == 3222) { return G4SigmaPlus::SigmaPlus();
  } else if(PDGCode == 3212) { return G4SigmaZero::SigmaZero();
  } else if(PDGCode == 3112) { return G4SigmaMinus::SigmaMinus();
  } else if(PDGCode == 321)  { return G4KaonPlus::KaonPlus();
  } else if(PDGCode == -321) { return G4KaonMinus::KaonMinus();
  } else if(PDGCode == 130)  { return G4KaonZeroLong::KaonZeroLong();
  } else if(PDGCode == 310)  { return G4KaonZeroShort::KaonZeroShort();
  
  } else if(PDGCode == 1002) { return G4Deuteron::Deuteron();
  } else if(PDGCode == 1003) { return G4Triton::Triton();
  } else if(PDGCode == 2003) { return G4He3::He3();
  } else if(PDGCode == 2004) { return G4Alpha::Alpha();
  } else if(S != 0) {  // Assumed that -S gives the number of Lambdas
    if (A == 3 && Z == 1 && S == -1 ) return G4HyperTriton::Definition();
    if (A == 4 && Z == 1 && S == -1 ) return G4HyperH4::Definition();
    if (A == 4 && Z == 2 && S == -1 ) return G4HyperAlpha::Definition();
    if (A == 4 && Z == 1 && S == -2 ) return G4DoubleHyperH4::Definition();
    if (A == 4 && Z == 0 && S == -2 ) return G4DoubleHyperDoubleNeutron::Definition();
    if (A == 5 && Z == 2 && S == -1 ) return G4HyperHe5::Definition();
  } else if(A > 0 && Z > 0 && A > Z) { // Returns ground state ion definition.
    return theIonTable->GetIon(Z, A, 0);
  }
  return 0; // Error, unrecognized particle
}

References A, G4Alpha::Alpha(), G4DoubleHyperDoubleNeutron::Definition(), G4DoubleHyperH4::Definition(), G4HyperAlpha::Definition(), G4HyperH4::Definition(), G4HyperHe5::Definition(), G4HyperTriton::Definition(), G4Deuteron::Deuteron(), G4Eta::Eta(), G4Gamma::Gamma(), G4IonTable::GetIon(), G4He3::He3(), G4KaonMinus::KaonMinus(), G4KaonPlus::KaonPlus(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), G4Lambda::Lambda(), G4Neutron::Neutron(), G4PionMinus::PionMinus(), G4PionPlus::PionPlus(), G4PionZero::PionZero(), G4Proton::Proton(), S(), G4SigmaMinus::SigmaMinus(), G4SigmaPlus::SigmaPlus(), G4SigmaZero::SigmaZero(), theIonTable, G4Triton::Triton(), and Z.

Referenced by toG4Particle().

toINCLKineticEnergy()

G4double G4INCLXXInterface::toINCLKineticEnergy ( G4HadProjectile const &  aTrack ) const

private

Convert G4HadProjectile to corresponding INCL particle kinetic energy.

Definition at line 564 of file G4INCLXXInterface.cc.

                                                                                   {
  return aTrack.GetKineticEnergy();
}

References G4HadProjectile::GetKineticEnergy().

Referenced by ApplyYourself().

toINCLParticleSpecies()

G4INCL::ParticleSpecies G4INCLXXInterface::toINCLParticleSpecies ( G4HadProjectile const &  aTrack ) const

private

Convert G4HadProjectile to corresponding INCL particle species.

Definition at line 550 of file G4INCLXXInterface.cc.

                                                                                                  {
  const G4ParticleDefinition *pdef = aTrack.GetDefinition();
  const G4INCL::ParticleType theType = toINCLParticleType(pdef);
  if(theType!=G4INCL::Composite)
    return G4INCL::ParticleSpecies(theType);
  else {
    G4INCL::ParticleSpecies theSpecies;
    theSpecies.theType=theType;
    theSpecies.theA=pdef->GetAtomicMass();
    theSpecies.theZ=pdef->GetAtomicNumber();
    return theSpecies;
  }
}

References G4INCL::Composite, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4HadProjectile::GetDefinition(), G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theType, G4INCL::ParticleSpecies::theZ, and toINCLParticleType().

Referenced by ApplyYourself().

toINCLParticleType()

G4INCL::ParticleType G4INCLXXInterface::toINCLParticleType ( G4ParticleDefinition const * const  pdef ) const

private

Convert G4ParticleDefinition to corresponding INCL particle type.

Definition at line 529 of file G4INCLXXInterface.cc.

                                                                                                      {
  if(     pdef == G4Proton::Proton())               return G4INCL::Proton;
  else if(pdef == G4Neutron::Neutron())             return G4INCL::Neutron;
  else if(pdef == G4PionPlus::PionPlus())           return G4INCL::PiPlus;
  else if(pdef == G4PionMinus::PionMinus())         return G4INCL::PiMinus;
  else if(pdef == G4PionZero::PionZero())           return G4INCL::PiZero;
  else if(pdef == G4KaonPlus::KaonPlus())           return G4INCL::KPlus;
  else if(pdef == G4KaonZero::KaonZero())           return G4INCL::KZero;
  else if(pdef == G4KaonMinus::KaonMinus())         return G4INCL::KMinus;
  else if(pdef == G4AntiKaonZero::AntiKaonZero())   return G4INCL::KZeroBar;
  // For K0L & K0S we do not take into account K0/K0B oscillations
  else if(pdef == G4KaonZeroLong::KaonZeroLong())   return G4UniformRand() < 0.5 ? G4INCL::KZeroBar : G4INCL::KZero;
  else if(pdef == G4KaonZeroShort::KaonZeroShort()) return G4UniformRand() < 0.5 ? G4INCL::KZeroBar : G4INCL::KZero; 
  else if(pdef == G4Deuteron::Deuteron())           return G4INCL::Composite;
  else if(pdef == G4Triton::Triton())               return G4INCL::Composite;
  else if(pdef == G4He3::He3())                     return G4INCL::Composite;
  else if(pdef == G4Alpha::Alpha())                 return G4INCL::Composite;
  else if(pdef->GetParticleType() == G4GenericIon::GenericIon()->GetParticleType()) return G4INCL::Composite;
  else                                              return G4INCL::UnknownParticle;
}

References G4Alpha::Alpha(), G4AntiKaonZero::AntiKaonZero(), G4INCL::Composite, G4Deuteron::Deuteron(), G4UniformRand, G4GenericIon::GenericIon(), G4ParticleDefinition::GetParticleType(), G4He3::He3(), G4KaonMinus::KaonMinus(), G4KaonPlus::KaonPlus(), G4KaonZero::KaonZero(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), G4INCL::KMinus, G4INCL::KPlus, G4INCL::KZero, G4INCL::KZeroBar, G4Neutron::Neutron(), G4INCL::Neutron, G4INCL::PiMinus, G4PionMinus::PionMinus(), G4PionPlus::PionPlus(), G4PionZero::PionZero(), G4INCL::PiPlus, G4INCL::PiZero, G4Proton::Proton(), G4INCL::Proton, G4Triton::Triton(), and G4INCL::UnknownParticle.

Referenced by toINCLParticleSpecies().

Field Documentation

complainedAboutBackupModel

G4bool G4INCLXXInterface::complainedAboutBackupModel

private

Definition at line 178 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself().

complainedAboutPreCompound

G4bool G4INCLXXInterface::complainedAboutPreCompound

private

Definition at line 179 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself().

dumpRemnantInfo

G4bool G4INCLXXInterface::dumpRemnantInfo

private

Definition at line 183 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and G4INCLXXInterface().

epCheckLevels

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

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

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

isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

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

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().

secID

G4int G4INCLXXInterface::secID

private

Definition at line 188 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and G4INCLXXInterface().

the3DNucleus

G4V3DNucleus* G4VIntraNuclearTransportModel::the3DNucleus

protectedinherited

Definition at line 107 of file G4VIntraNuclearTransportModel.hh.

Referenced by G4BinaryCascade::ApplyYourself(), G4BinaryCascade::BuildTargetList(), G4BinaryCascade::CheckChargeAndBaryonNumber(), G4BinaryCascade::CheckPauliPrinciple(), G4BinaryCascade::FindFragments(), G4VIntraNuclearTransportModel::Get3DNucleus(), G4BinaryCascade::GetExcitationEnergy(), G4BinaryCascade::Propagate(), and G4VIntraNuclearTransportModel::Set3DNucleus().

theBackupModel

G4HadronicInteraction* G4INCLXXInterface::theBackupModel

private

Definition at line 172 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and G4INCLXXInterface().

theBackupModelNucleon

G4HadronicInteraction* G4INCLXXInterface::theBackupModelNucleon

private

Definition at line 173 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and G4INCLXXInterface().

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().

theDeExcitation

G4VPreCompoundModel* G4VIntraNuclearTransportModel::theDeExcitation

protectedinherited

Definition at line 109 of file G4VIntraNuclearTransportModel.hh.

Referenced by G4BinaryCascade::ApplyYourself(), ApplyYourself(), G4BinaryCascade::DeExcite(), G4INCLXXInterface(), G4VIntraNuclearTransportModel::GetDeExcitation(), GetDeExcitationModelName(), G4BinaryCascade::ModelDescription(), G4GeneratorPrecompoundInterface::Propagate(), G4BinaryCascade::PropagateModelDescription(), G4GeneratorPrecompoundInterface::PropagateNuclNucl(), and G4VIntraNuclearTransportModel::SetDeExcitation().

theINCLModel

G4INCL::INCL* G4INCLXXInterface::theINCLModel

private

Definition at line 166 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and DeleteModel().

theINCLXXFissionProbability

G4FissionProbability* G4INCLXXInterface::theINCLXXFissionProbability

private

Definition at line 186 of file G4INCLXXInterface.hh.

Referenced by G4INCLXXInterface(), and ~G4INCLXXInterface().

theINCLXXLevelDensity

G4VLevelDensityParameter* G4INCLXXInterface::theINCLXXLevelDensity

private

Definition at line 185 of file G4INCLXXInterface.hh.

Referenced by G4INCLXXInterface(), and ~G4INCLXXInterface().

theInterfaceStore

G4INCLXXInterfaceStore* const G4INCLXXInterface::theInterfaceStore

private

Definition at line 175 of file G4INCLXXInterface.hh.

Referenced by AccurateProjectile(), ApplyYourself(), and G4INCLXXInterface().

theIonTable

G4IonTable* const G4INCLXXInterface::theIonTable

private

Definition at line 181 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and toG4ParticleDefinition().

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().

theParticleChange

G4HadFinalState G4HadronicInteraction::theParticleChange

protectedinherited

Definition at line 172 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4ElectroVDNuclearModel::ApplyYourself(), G4ParticleHPThermalScattering::ApplyYourself(), G4NeutrinoElectronNcModel::ApplyYourself(), G4NeutronElectronElModel::ApplyYourself(), G4LFission::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4MuonVDNuclearModel::ApplyYourself(), G4NeutrinoElectronCcModel::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4ElectroVDNuclearModel::CalculateEMVertex(), G4MuonVDNuclearModel::CalculateEMVertex(), G4ElectroVDNuclearModel::CalculateHadronicVertex(), G4MuonVDNuclearModel::CalculateHadronicVertex(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::copyOutputToHadronicResult(), G4BinaryCascade::DebugEpConservation(), G4BinaryCascade::DebugFinalEpConservation(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), G4WilsonAbrasionModel::GetAbradedNucleons(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4NeutrinoNucleusModel::RecoilDeexcitation(), G4LEHadronProtonElastic::~G4LEHadronProtonElastic(), G4LEnp::~G4LEnp(), and G4LFission::~G4LFission().

thePreCompoundModel

G4VPreCompoundModel* G4INCLXXInterface::thePreCompoundModel

private

Definition at line 168 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself(), and G4INCLXXInterface().

thePrimaryProjectile

const G4HadProjectile* G4VIntraNuclearTransportModel::thePrimaryProjectile

protectedinherited

Definition at line 111 of file G4VIntraNuclearTransportModel.hh.

Referenced by G4VIntraNuclearTransportModel::GetPrimaryProjectile(), and G4VIntraNuclearTransportModel::SetPrimaryProjectile().

theResult

G4HadFinalState G4INCLXXInterface::theResult

private

Definition at line 170 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself().

theTally

G4INCLXXVInterfaceTally* G4INCLXXInterface::theTally

private

Definition at line 176 of file G4INCLXXInterface.hh.

Referenced by ApplyYourself().

theTransportModelName

G4String G4VIntraNuclearTransportModel::theTransportModelName

protectedinherited

Definition at line 105 of file G4VIntraNuclearTransportModel.hh.

Referenced by G4VIntraNuclearTransportModel::GetModelName().

verboseLevel

G4int G4HadronicInteraction::verboseLevel

protectedinherited

Definition at line 177 of file G4HadronicInteraction.hh.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4LFission::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4CascadeInterface::checkFinalResult(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4LENDModel::create_used_target_map(), G4CascadeInterface::createBullet(), G4CascadeInterface::createTarget(), G4ElasticHadrNucleusHE::DefineHadronValues(), G4ElasticHadrNucleusHE::FillData(), G4ElasticHadrNucleusHE::FillFq2(), G4DiffuseElastic::G4DiffuseElastic(), G4DiffuseElasticV2::G4DiffuseElasticV2(), G4ElasticHadrNucleusHE::G4ElasticHadrNucleusHE(), G4EMDissociation::G4EMDissociation(), G4hhElastic::G4hhElastic(), G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), G4ElasticHadrNucleusHE::GetFt(), G4ElasticHadrNucleusHE::GetLightFq2(), G4ElasticHadrNucleusHE::GetQ2_2(), G4HadronicInteraction::GetVerboseLevel(), G4ElasticHadrNucleusHE::HadronNucleusQ2_2(), G4ElasticHadrNucleusHE::HadronProtonQ2(), G4LFission::init(), G4DiffuseElastic::Initialise(), G4DiffuseElasticV2::Initialise(), G4NuclNuclDiffuseElastic::Initialise(), G4DiffuseElastic::InitialiseOnFly(), G4DiffuseElasticV2::InitialiseOnFly(), G4NuclNuclDiffuseElastic::InitialiseOnFly(), G4CascadeInterface::makeDynamicParticle(), G4CascadeInterface::NoInteraction(), G4CascadeInterface::Propagate(), G4ElasticHadrNucleusHE::SampleInvariantT(), G4AntiNuclElastic::SampleThetaCMS(), G4DiffuseElastic::SampleThetaLab(), G4NuclNuclDiffuseElastic::SampleThetaLab(), G4AntiNuclElastic::SampleThetaLab(), G4WilsonAbrasionModel::SetUseAblation(), G4HadronicInteraction::SetVerboseLevel(), G4WilsonAbrasionModel::SetVerboseLevel(), G4DiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElasticV2::ThetaCMStoThetaLab(), G4NuclNuclDiffuseElastic::ThetaCMStoThetaLab(), G4DiffuseElastic::ThetaLabToThetaCMS(), G4DiffuseElasticV2::ThetaLabToThetaCMS(), and G4NuclNuclDiffuseElastic::ThetaLabToThetaCMS().

---

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

• source/processes/hadronic/models/inclxx/interface/include/G4INCLXXInterface.hh
• source/processes/hadronic/models/inclxx/interface/src/G4INCLXXInterface.cc