G4GeneratorPrecompoundInterface Class Reference

#include <G4GeneratorPrecompoundInterface.hh>

Inheritance diagram for G4GeneratorPrecompoundInterface:

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)
	G4GeneratorPrecompoundInterface (G4VPreCompoundModel *p=0)
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
void	MakeCoalescence (G4KineticTrackVector *theSecondaries)
virtual void	ModelDescription (std::ostream &outFile) const
G4bool	operator!= (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4VIntraNuclearTransportModel &right) const =delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator== (const G4VIntraNuclearTransportModel &right) const =delete
virtual G4ReactionProductVector *	Propagate (G4KineticTrackVector *theSecondaries, G4V3DNucleus *theNucleus)
virtual void	PropagateModelDescription (std::ostream &) 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	SetCaptureThreshold (G4double)
void	SetDeExcitation (G4VPreCompoundModel *ptr)
void	SetDeltaM (G4double)
void	SetDeltaR (G4double)
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)
virtual	~G4GeneratorPrecompoundInterface ()

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
	G4GeneratorPrecompoundInterface (const G4GeneratorPrecompoundInterface &right)
G4bool	operator!= (G4GeneratorPrecompoundInterface &right)
const G4GeneratorPrecompoundInterface &	operator= (const G4GeneratorPrecompoundInterface &right)
G4bool	operator== (G4GeneratorPrecompoundInterface &right)

Private Attributes
const G4ParticleDefinition *	ANTIdeuteron
const G4ParticleDefinition *	ANTIHe3
const G4ParticleDefinition *	ANTIHe4
const G4ParticleDefinition *	ANTIneutron
const G4ParticleDefinition *	ANTIproton
const G4ParticleDefinition *	ANTItriton
G4double	CaptureThreshold
G4double	DeltaM
G4double	DeltaR
const G4ParticleDefinition *	deuteron
std::pair< G4double, G4double >	epCheckLevels
const G4ParticleDefinition *	He3
const G4ParticleDefinition *	He4
const G4ParticleDefinition *	neutron
const G4ParticleDefinition *	proton
G4double	recoilEnergyThreshold
G4HadronicInteractionRegistry *	registry
G4int	secID
std::vector< const G4Material * >	theBlockedList
std::vector< const G4Element * >	theBlockedListElements
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
const G4ParticleDefinition *	triton

Detailed Description

Definition at line 59 of file G4GeneratorPrecompoundInterface.hh.

Constructor & Destructor Documentation

G4GeneratorPrecompoundInterface() [1/2]

G4GeneratorPrecompoundInterface::G4GeneratorPrecompoundInterface

(

G4VPreCompoundModel *

p = 0

)

Definition at line 98 of file G4GeneratorPrecompoundInterface.cc.

  : CaptureThreshold(70*MeV), DeltaM(5.0*MeV), DeltaR(0.0), secID(-1)
{
   proton = G4Proton::Proton();
   neutron = G4Neutron::Neutron();
 
   deuteron=G4Deuteron::Deuteron();
   triton  =G4Triton::Triton();
   He3     =G4He3::He3();
   He4     =G4Alpha::Alpha();
 
   ANTIproton=G4AntiProton::AntiProton();
   ANTIneutron=G4AntiNeutron::AntiNeutron();
 
   ANTIdeuteron=G4AntiDeuteron::AntiDeuteron();
   ANTItriton  =G4AntiTriton::AntiTriton();
   ANTIHe3     =G4AntiHe3::AntiHe3();
   ANTIHe4     =G4AntiAlpha::AntiAlpha();
 
   if(preModel) { SetDeExcitation(preModel); }
   else  {
      G4HadronicInteraction* hadi =
            G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
      G4VPreCompoundModel* pre = static_cast<G4VPreCompoundModel*>(hadi);
      if(!pre) { pre = new G4PreCompoundModel(); }
      SetDeExcitation(pre);
   }
 
   secID = G4PhysicsModelCatalog::GetModelID("model_PRECO");
}

References G4Alpha::Alpha(), G4AntiAlpha::AntiAlpha(), G4AntiDeuteron::AntiDeuteron(), ANTIdeuteron, G4AntiHe3::AntiHe3(), ANTIHe3, ANTIHe4, G4AntiNeutron::AntiNeutron(), ANTIneutron, G4AntiProton::AntiProton(), ANTIproton, G4AntiTriton::AntiTriton(), ANTItriton, G4Deuteron::Deuteron(), deuteron, G4HadronicInteractionRegistry::FindModel(), G4PhysicsModelCatalog::GetModelID(), G4He3::He3(), He3, He4, G4HadronicInteractionRegistry::Instance(), G4Neutron::Neutron(), neutron, G4Proton::Proton(), proton, secID, G4VIntraNuclearTransportModel::SetDeExcitation(), G4Triton::Triton(), and triton.

~G4GeneratorPrecompoundInterface()

G4GeneratorPrecompoundInterface::~G4GeneratorPrecompoundInterface ( )

virtual

Definition at line 129 of file G4GeneratorPrecompoundInterface.cc.

{
}

G4GeneratorPrecompoundInterface() [2/2]

G4GeneratorPrecompoundInterface::G4GeneratorPrecompoundInterface ( const G4GeneratorPrecompoundInterface &  right )

private

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

ApplyYourself()

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

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 349 of file G4GeneratorPrecompoundInterface.cc.

{
   G4cout << "G4GeneratorPrecompoundInterface: ApplyYourself interface called stand-allone."
         << G4endl;
   G4cout << "This class is only a mediator between generator and precompound"<<G4endl;
   G4cout << "Please remove from your physics list."<<G4endl;
   throw G4HadronicException(__FILE__, __LINE__, "SEVERE: G4GeneratorPrecompoundInterface model interface called stand-allone.");
   return new G4HadFinalState;
}

References G4cout, and G4endl.

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

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

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(), Propagate(), G4CascadeInterface::Propagate(), and 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.

MakeCoalescence()

void G4GeneratorPrecompoundInterface::MakeCoalescence

(

G4KineticTrackVector *

theSecondaries

)

Definition at line 786 of file G4GeneratorPrecompoundInterface.cc.

                                                                                  {
  // This method replaces pairs of proton-neutron - in the case of nuclei - or
  // antiproton-antineutron - in the case of anti-nuclei - which are close in
  // momentum, with, respectively, deuterons and anti-deuterons.
  // Note that in the case of hypernuclei or anti-hypernuclei, lambdas or anti-lambdas
  // are not considered for coalescence because hyper-deuteron or anti-hyper-deuteron
  // are assumed not to exist.
  
  if (!tracks) return;
 
  G4double MassCut = deuteron->GetPDGMass() + DeltaM;   // In MeV
 
  for ( size_t i = 0; i < tracks->size(); ++i ) {  // search for protons
 
    G4KineticTrack* trackP = (*tracks)[i];
    if ( ! trackP ) continue;
    if (trackP->GetDefinition() != proton) continue;
 
    G4LorentzVector Prot4Mom = trackP->Get4Momentum();
    G4LorentzVector ProtSPposition = G4LorentzVector(trackP->GetPosition(), trackP->GetFormationTime());
 
    for ( size_t j = 0; j < tracks->size(); ++j ) {  // search for neutron
                                                
      G4KineticTrack* trackN = (*tracks)[j];
      if (! trackN ) continue;
      if (trackN->GetDefinition() != neutron) continue;
 
      G4LorentzVector Neut4Mom = trackN->Get4Momentum();
      G4LorentzVector NeutSPposition = G4LorentzVector( trackN->GetPosition(), trackN->GetFormationTime()*hbarc/fermi);
      G4double EffMass = (Prot4Mom + Neut4Mom).mag();
 
      if ( EffMass <= MassCut ) {  // && (EffDistance <= SpaceCut)) { // Create deuteron
        G4KineticTrack* aDeuteron = 
          new G4KineticTrack( deuteron,
                              (trackP->GetFormationTime() +  trackN->GetFormationTime())/2.0,
                              (trackP->GetPosition()      +  trackN->GetPosition()     )/2.0,
                              ( Prot4Mom                  +  Neut4Mom                        ));
        aDeuteron->SetCreatorModelID(secID);
        tracks->push_back(aDeuteron);
        delete trackP; delete trackN;
        (*tracks)[i] = nullptr; (*tracks)[j] = nullptr;
        break;
      }
    }
  }
 
  // Find and remove null pointers created by decays above
  for ( int jj = tracks->size()-1; jj >= 0; --jj ) {
    if ( ! (*tracks)[jj] ) tracks->erase(tracks->begin()+jj);
  }
 
}

References DeltaM, deuteron, fermi, G4KineticTrack::Get4Momentum(), G4KineticTrack::GetDefinition(), G4KineticTrack::GetFormationTime(), G4ParticleDefinition::GetPDGMass(), G4KineticTrack::GetPosition(), source.hepunit::hbarc, neutron, proton, secID, and G4KineticTrack::SetCreatorModelID().

Referenced by PropagateNuclNucl().

ModelDescription()

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

virtualinherited

Reimplemented from G4HadronicInteraction.

Reimplemented in G4BinaryCascade, G4CascadeInterface, and G4INCLXXInterface.

Definition at line 50 of file G4VIntraNuclearTransportModel.cc.

{
  outFile << "G4VIntraNuclearTransportModel is abstract class.\n";
  G4Exception("G4VIntraNuclearTransportModel::ModelDescription()","G4VINT01",
              FatalException,
              "G4VIntraNuclearTransportModel is abstract class, no description available");
}

References FatalException, and G4Exception().

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 G4GeneratorPrecompoundInterface::operator!= ( G4GeneratorPrecompoundInterface &  right )

inlineprivate

Definition at line 90 of file G4GeneratorPrecompoundInterface.hh.

{return (this != &right);}

operator=()

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

private

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 G4GeneratorPrecompoundInterface::operator== ( G4GeneratorPrecompoundInterface &  right )

inlineprivate

Definition at line 89 of file G4GeneratorPrecompoundInterface.hh.

{return (this == &right);}

Propagate()

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

virtual

Implements G4VIntraNuclearTransportModel.

Definition at line 133 of file G4GeneratorPrecompoundInterface.cc.

{
   #ifdef debugPrecoInt
      G4cout<<G4endl<<"G4GeneratorPrecompoundInterface::Propagate"<<G4endl;
      G4cout<<"Target A and Z "<<theNucleus->GetMassNumber()<<" "<<theNucleus->GetCharge()<<G4endl;
      G4cout<<"Directly produced particles number "<<theSecondaries->size()<<G4endl;
   #endif
 
   G4ReactionProductVector * theTotalResult = new G4ReactionProductVector;
 
   // decay the strong resonances
   G4DecayKineticTracks decay(theSecondaries);
   #ifdef debugPrecoInt
      G4cout<<"Final stable particles number "<<theSecondaries->size()<<G4endl;
   #endif
 
   // prepare the fragment (it is assumed that target nuclei are never hypernuclei)
   G4int anA=theNucleus->GetMassNumber();
   G4int aZ=theNucleus->GetCharge();
// G4double TargetNucleusMass =  G4NucleiProperties::GetNuclearMass(anA, aZ);
 
   G4int numberOfEx = 0;
   G4int numberOfCh = 0;
   G4int numberOfHoles = 0;
 
   G4double R = theNucleus->GetNuclearRadius();
 
   G4LorentzVector captured4Momentum(0.,0.,0.,0.);
   G4LorentzVector Residual4Momentum(0.,0.,0.,0.);  // TargetNucleusMass is not need at the moment 
   G4LorentzVector Secondary4Momentum(0.,0.,0.,0.);
 
   // loop over secondaries
   G4KineticTrackVector::iterator iter;
   for(iter=theSecondaries->begin(); iter !=theSecondaries->end(); ++iter)
   {
      const G4ParticleDefinition* part = (*iter)->GetDefinition();
      G4double e = (*iter)->Get4Momentum().e();
      G4double mass = (*iter)->Get4Momentum().mag();
      G4ThreeVector mom = (*iter)->Get4Momentum().vect();
      if((part != proton && part != neutron) ||
            ((*iter)->GetPosition().mag() > R)) {
         G4ReactionProduct * theNew = new G4ReactionProduct(part);
         theNew->SetMomentum(mom);
         theNew->SetTotalEnergy(e);
     theNew->SetCreatorModelID((*iter)->GetCreatorModelID());
         theTotalResult->push_back(theNew);
         Secondary4Momentum += (*iter)->Get4Momentum();
         #ifdef debugPrecoInt
            G4cout<<"Secondary 4Mom "<<part->GetParticleName()<<" "<<(*iter)->Get4Momentum()<<" "
                  <<(*iter)->Get4Momentum().mag()<<G4endl;
         #endif
      } else {
         if( e-mass > -CaptureThreshold*G4Log( G4UniformRand()) ) {
            G4ReactionProduct * theNew = new G4ReactionProduct(part);
            theNew->SetMomentum(mom);
            theNew->SetTotalEnergy(e);
        theNew->SetCreatorModelID((*iter)->GetCreatorModelID());
            theTotalResult->push_back(theNew);
            Secondary4Momentum += (*iter)->Get4Momentum();
            #ifdef debugPrecoInt
               G4cout<<"Secondary 4Mom "<<part->GetParticleName()<<" "<<(*iter)->Get4Momentum()<<" "
                     <<(*iter)->Get4Momentum().mag()<<G4endl;
            #endif
         } else {
            // within the nucleus, neutron or proton
            // now calculate  A, Z of the fragment, momentum, number of exciton states
            ++anA;
            ++numberOfEx;
            G4int Z = G4int(part->GetPDGCharge()/eplus + 0.1);
            aZ += Z;
            numberOfCh += Z;
            captured4Momentum += (*iter)->Get4Momentum();
            #ifdef debugPrecoInt
               G4cout<<"Captured  4Mom "<<part->GetParticleName()<<(*iter)->Get4Momentum()<<G4endl;
            #endif
         }
      }
      delete (*iter);
   }
   delete theSecondaries;
 
   // loop over wounded nucleus
   G4Nucleon * theCurrentNucleon =
         theNucleus->StartLoop() ? theNucleus->GetNextNucleon() : 0;
   while(theCurrentNucleon)    /* Loop checking, 31.08.2015, G.Folger */
    {
      if(theCurrentNucleon->AreYouHit()) {
         ++numberOfHoles;
         ++numberOfEx;
         --anA;
         aZ -= G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/eplus + 0.1);
 
         Residual4Momentum -= theCurrentNucleon->Get4Momentum();
      }
      theCurrentNucleon = theNucleus->GetNextNucleon();
   }
 
   #ifdef debugPrecoInt
      G4cout<<G4endl;
      G4cout<<"Secondary 4Mom "<<Secondary4Momentum<<G4endl;
      G4cout<<"Captured  4Mom "<<captured4Momentum<<G4endl;
      G4cout<<"Sec + Captured "<<Secondary4Momentum+captured4Momentum<<G4endl;
      G4cout<<"Residual4Mom   "<<Residual4Momentum<<G4endl;
      G4cout<<"Sum 4 momenta  "
            <<Secondary4Momentum + captured4Momentum + Residual4Momentum <<G4endl;
   #endif
 
   // Check that we use QGS model; loop over wounded nucleus
   G4bool QGSM(false);
   theCurrentNucleon = theNucleus->StartLoop() ? theNucleus->GetNextNucleon() : 0;
   while(theCurrentNucleon)   /* Loop checking, 31.08.2015, G.Folger */
    {
      if(theCurrentNucleon->AreYouHit()) 
      {
       if(theCurrentNucleon->Get4Momentum().mag() < 
          theCurrentNucleon->GetDefinition()->GetPDGMass()) QGSM=true;
      }
      theCurrentNucleon = theNucleus->GetNextNucleon();
   }
 
   #ifdef debugPrecoInt
      if(!QGSM){
        G4cout<<G4endl;
        G4cout<<"Residual A and Z "<<anA<<" "<<aZ<<G4endl;
        G4cout<<"Residual  4Mom "<<Residual4Momentum<<G4endl;
        if(numberOfEx == 0) 
        {G4cout<<"Residual  4Mom = 0 means that there were not wounded and captured nucleons"<<G4endl;}
      }
   #endif
 
   if(anA == 0) return theTotalResult;
 
   G4LorentzVector exciton4Momentum(0.,0.,0.,0.);
   if(anA >= aZ)
   {
    if(!QGSM)
    {          // FTF model was used  
      G4double fMass =  G4NucleiProperties::GetNuclearMass(anA, aZ);
 
//      G4LorentzVector exciton4Momentum = Residual4Momentum + captured4Momentum;
      exciton4Momentum = Residual4Momentum + captured4Momentum;
//exciton4Momentum.setE(std::sqrt(exciton4Momentum.vect().mag2()+sqr(fMass)));
      G4double ActualMass = exciton4Momentum.mag();      
      if(ActualMass <= fMass ) {
        exciton4Momentum.setE(std::sqrt(exciton4Momentum.vect().mag2()+sqr(fMass)));
      }
 
      #ifdef debugPrecoInt
         G4double exEnergy = 0.0;
         if(ActualMass <= fMass ) {exEnergy = 0.;}
         else                     {exEnergy = ActualMass - fMass;}
         G4cout<<"Ground state residual Mass "<<fMass<<" E* "<<exEnergy<<G4endl;
      #endif
    }
    else
    {          // QGS model was used 
     G4double InitialTargetMass = 
              G4NucleiProperties::GetNuclearMass(theNucleus->GetMassNumber(), theNucleus->GetCharge());
 
     exciton4Momentum = 
              GetPrimaryProjectile()->Get4Momentum() + G4LorentzVector(0.,0.,0.,InitialTargetMass)
             -Secondary4Momentum;
 
     G4double fMass =  G4NucleiProperties::GetNuclearMass(anA, aZ);
     G4double ActualMass = exciton4Momentum.mag();
 
     #ifdef debugPrecoInt
        G4cout<<G4endl;
        G4cout<<"Residual A and Z "<<anA<<" "<<aZ<<G4endl;
        G4cout<<"Residual4Momentum "<<exciton4Momentum<<G4endl;
        G4cout<<"ResidualMass, GroundStateMass and E* "<<ActualMass<<" "<<fMass<<" "
              <<ActualMass - fMass<<G4endl;
     #endif
 
     if(ActualMass - fMass < 0.)
     {
      G4double ResE = std::sqrt(exciton4Momentum.vect().mag2() + sqr(fMass+10*MeV));
      exciton4Momentum.setE(ResE);
      #ifdef debugPrecoInt
         G4cout<<"ActualMass - fMass < 0. "<<ActualMass<<" "<<fMass<<" "<<ActualMass - fMass<<G4endl;
         G4int Uzhi; G4cin>>Uzhi;
      #endif
     }
    }
 
    // Need to de-excite the remnant nucleus only if excitation energy > 0.
    G4Fragment anInitialState(anA, aZ, exciton4Momentum);
    anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
    anInitialState.SetNumberOfCharged(numberOfCh);
    anInitialState.SetNumberOfHoles(numberOfHoles);
    anInitialState.SetCreatorModelID(secID);
 
    G4ReactionProductVector * aPrecoResult =
      theDeExcitation->DeExcite(anInitialState);
    // fill pre-compound part into the result, and return
    #ifdef debugPrecoInt
    G4cout<<"Target fragment number "<<aPrecoResult->size()<<G4endl;
    #endif
    for(unsigned int ll=0; ll<aPrecoResult->size(); ++ll)
    {
      theTotalResult->push_back(aPrecoResult->operator[](ll));
      #ifdef debugPrecoInt
      G4cout<<"Fragment "<<ll<<" "
        <<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()<<" "
        <<aPrecoResult->operator[](ll)->GetMomentum()<<" "
        <<aPrecoResult->operator[](ll)->GetTotalEnergy()<<" "
        <<aPrecoResult->operator[](ll)->GetDefinition()->GetPDGMass()<<G4endl;
       #endif
    }
    delete aPrecoResult;
   }
 
   return theTotalResult;
}

References G4Nucleon::AreYouHit(), CaptureThreshold, G4INCL::ClusterDecay::decay(), G4VPreCompoundModel::DeExcite(), eplus, G4cin, G4cout, G4endl, G4Log(), G4UniformRand, G4HadProjectile::Get4Momentum(), G4Nucleon::Get4Momentum(), G4V3DNucleus::GetCharge(), G4Nucleon::GetDefinition(), G4V3DNucleus::GetMassNumber(), G4V3DNucleus::GetNextNucleon(), G4NucleiProperties::GetNuclearMass(), G4V3DNucleus::GetNuclearRadius(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4VIntraNuclearTransportModel::GetPrimaryProjectile(), CLHEP::HepLorentzVector::mag(), CLHEP::Hep3Vector::mag2(), MeV, neutron, proton, secID, G4ReactionProduct::SetCreatorModelID(), G4Fragment::SetCreatorModelID(), CLHEP::HepLorentzVector::setE(), G4ReactionProduct::SetMomentum(), G4Fragment::SetNumberOfCharged(), G4Fragment::SetNumberOfHoles(), G4Fragment::SetNumberOfParticles(), G4ReactionProduct::SetTotalEnergy(), sqr(), G4V3DNucleus::StartLoop(), G4VIntraNuclearTransportModel::theDeExcitation, CLHEP::HepLorentzVector::vect(), and Z.

PropagateModelDescription()

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

virtual

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 359 of file G4GeneratorPrecompoundInterface.cc.

{
   outFile << "G4GeneratorPrecompoundInterface interfaces a high\n"
         << "energy model through the wounded nucleus to precompound de-excitation.\n"
         << "Low energy protons and neutron present among secondaries produced by \n"
         << "the high energy generator and within the nucleus are captured. The wounded\n"
         << "nucleus and the captured particles form an excited nuclear fragment. This\n"
         << "fragment is passed to the Geant4 pre-compound model for de-excitation.\n"
         << "Nuclear de-excitation:\n";
   // preco
 
}

PropagateNuclNucl()

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

virtual

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 373 of file G4GeneratorPrecompoundInterface.cc.

{
#ifdef debugPrecoInt
   G4cout<<G4endl<<"G4GeneratorPrecompoundInterface::PropagateNuclNucl "<<G4endl;
   G4cout<<"Projectile A and Z (and numberOfLambdas) "<<theProjectileNucleus->GetMassNumber()<<" "
     <<theProjectileNucleus->GetCharge()<<" ("
     <<theProjectileNucleus->GetNumberOfLambdas()<<")"<<G4endl;
   G4cout<<"Target     A and Z "<<theNucleus->GetMassNumber()<<" "
         <<theNucleus->GetCharge()<<" ("
     <<theNucleus->GetNumberOfLambdas()<<")"<<G4endl;
   G4cout<<"Directly produced particles number "<<theSecondaries->size()<<G4endl;
   G4cout<<"Projectile 4Mom and mass "<<GetPrimaryProjectile()->Get4Momentum()<<" "
                                      <<GetPrimaryProjectile()->Get4Momentum().mag()<<G4endl<<G4endl;
#endif
 
   // prepare the target residual (assumed to be never a hypernucleus)
   G4int anA=theNucleus->GetMassNumber();
   G4int aZ=theNucleus->GetCharge();
   //G4int aL=theNucleus->GetNumberOfLambdas();  // Should be 0
   G4int numberOfEx = 0;
   G4int numberOfCh = 0;
   G4int numberOfHoles = 0;
   G4double exEnergy = 0.0;
   G4double R = theNucleus->GetNuclearRadius();
   G4LorentzVector Target4Momentum(0.,0.,0.,0.);
 
   // loop over the wounded target nucleus
   G4Nucleon * theCurrentNucleon =
         theNucleus->StartLoop() ? theNucleus->GetNextNucleon() : 0;
   while(theCurrentNucleon)   /* Loop checking, 31.08.2015, G.Folger */
    {
      if(theCurrentNucleon->AreYouHit()) {
         ++numberOfHoles;
         ++numberOfEx;
         --anA;
         aZ -= G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
               eplus + 0.1);
         exEnergy += theCurrentNucleon->GetBindingEnergy();
         Target4Momentum -=theCurrentNucleon->Get4Momentum();
      }
      theCurrentNucleon = theNucleus->GetNextNucleon();
   }
 
#ifdef debugPrecoInt
   G4cout<<"Residual Target A Z (numberOfLambdas) E* 4mom "<<anA<<" "<<aZ<<" (0"//<<aL
         <<") "<<exEnergy<<" "<<Target4Momentum<<G4endl;
#endif
 
   // prepare the projectile residual - which can be a hypernucleus or anti-hypernucleus
 
   G4bool ProjectileIsAntiNucleus=
         GetPrimaryProjectile()->GetDefinition()->GetBaryonNumber() < -1;
 
   G4ThreeVector bst = GetPrimaryProjectile()->Get4Momentum().boostVector();
 
   G4int anAb=theProjectileNucleus->GetMassNumber();
   G4int aZb=theProjectileNucleus->GetCharge();
   G4int aLb=theProjectileNucleus->GetNumberOfLambdas();  // Non negative number of (anti-)lambdas in (anti-)nucleus
   G4int numberOfExB = 0;
   G4int numberOfChB = 0;
   G4int numberOfHolesB = 0;
   G4double exEnergyB = 0.0;
   G4double Rb = theProjectileNucleus->GetNuclearRadius();
   G4LorentzVector Projectile4Momentum(0.,0.,0.,0.);
 
   // loop over the wounded projectile nucleus or anti-nucleus
   theCurrentNucleon =
         theProjectileNucleus->StartLoop() ? theProjectileNucleus->GetNextNucleon() : 0;
   while(theCurrentNucleon)    /* Loop checking, 31.08.2015, G.Folger */
    {
      if(theCurrentNucleon->AreYouHit()) {
         ++numberOfHolesB;
         ++numberOfExB;
         --anAb;
         if(!ProjectileIsAntiNucleus) {
            aZb -= G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
                  eplus + 0.1);
        if (theCurrentNucleon->GetParticleType()==G4Lambda::Definition()) --aLb;
         } else {
            aZb += G4int(theCurrentNucleon->GetDefinition()->GetPDGCharge()/
                  eplus - 0.1);
        if (theCurrentNucleon->GetParticleType()==G4AntiLambda::Definition()) --aLb;
         }
         exEnergyB += theCurrentNucleon->GetBindingEnergy();
         Projectile4Momentum -=theCurrentNucleon->Get4Momentum();
      }
      theCurrentNucleon = theProjectileNucleus->GetNextNucleon();
   }
 
   G4bool ExistTargetRemnant   =  G4double (numberOfHoles)        <
         0.3* G4double (numberOfHoles + anA);
   G4bool ExistProjectileRemnant= G4double (numberOfHolesB)       <
         0.3*G4double (numberOfHolesB + anAb);
 
#ifdef debugPrecoInt
   G4cout<<"Projectile residual A Z (numberOfLambdas) E* 4mom "<<anAb<<" "<<aZb<<" ("<<aLb
     <<") "<<exEnergyB<<" "<<Projectile4Momentum<<G4endl;
   G4cout<<" ExistTargetRemnant ExistProjectileRemnant "
         <<ExistTargetRemnant<<" "<< ExistProjectileRemnant<<G4endl;
#endif
   //-----------------------------------------------------------------------------
   // decay the strong resonances
   G4ReactionProductVector * theTotalResult = new G4ReactionProductVector;
   G4DecayKineticTracks decay(theSecondaries);
 
   MakeCoalescence(theSecondaries);
 
   #ifdef debugPrecoInt
      G4cout<<"Secondary stable particles number "<<theSecondaries->size()<<G4endl;
   #endif
 
#ifdef debugPrecoInt
   G4LorentzVector secondary4Momemtum(0,0,0,0);
   G4int SecondrNum(0);
#endif
 
   // Loop over secondaries.
   // We are assuming that only protons and neutrons - for nuclei -
   // and only antiprotons and antineutrons - for antinuclei - can be absorbed,
   // not instead lambdas (or hyperons more generally) - for nuclei - or anti-lambdas
   // (or anti-hyperons more generally) - for antinuclei. This is a simplification,
   // to be eventually reviewed later on, in particular when generic hypernuclei and
   // anti-hypernuclei are introduced, instead of the few light hypernuclei and
   // anti-hypernuclei which currently exist in Geant4.
   G4KineticTrackVector::iterator iter;
   for(iter=theSecondaries->begin(); iter !=theSecondaries->end(); ++iter)
   {
      const G4ParticleDefinition* part = (*iter)->GetDefinition();
      G4LorentzVector aTrack4Momentum=(*iter)->Get4Momentum();
 
      if( part != proton && part != neutron &&
            (part != ANTIproton  && ProjectileIsAntiNucleus) &&
            (part != ANTIneutron && ProjectileIsAntiNucleus)   )
      {
         G4ReactionProduct * theNew = new G4ReactionProduct(part);
         theNew->SetMomentum(aTrack4Momentum.vect());
         theNew->SetTotalEnergy(aTrack4Momentum.e());
     theNew->SetCreatorModelID((*iter)->GetCreatorModelID());
         theTotalResult->push_back(theNew);
#ifdef debugPrecoInt
         SecondrNum++;
         secondary4Momemtum += (*iter)->Get4Momentum();
         G4cout<<"Secondary  "<<SecondrNum<<" "
               <<theNew->GetDefinition()->GetParticleName()<<" "
               <<theNew->GetMomentum()<<" "<<theNew->GetTotalEnergy()<<G4endl;
 
#endif
         delete (*iter);
         continue;
      }
 
      G4bool CanBeCapturedByTarget = false;
      if( part == proton || part == neutron)
      {
         CanBeCapturedByTarget = ExistTargetRemnant    &&
               (-CaptureThreshold*G4Log( G4UniformRand()) >
              (aTrack4Momentum       + Target4Momentum).mag() -
               aTrack4Momentum.mag() - Target4Momentum.mag())   &&
                   ((*iter)->GetPosition().mag() < R);
      }
      // ---------------------------
      G4LorentzVector Position((*iter)->GetPosition(), (*iter)->GetFormationTime());
      Position.boost(bst);
 
      G4bool CanBeCapturedByProjectile = false;
 
      if( !ProjectileIsAntiNucleus &&
            ( part == proton || part == neutron))
      {
         CanBeCapturedByProjectile = ExistProjectileRemnant &&
               (-CaptureThreshold*G4Log( G4UniformRand()) >
              (aTrack4Momentum       + Projectile4Momentum).mag() -
               aTrack4Momentum.mag() - Projectile4Momentum.mag())    &&
                   (Position.vect().mag() < Rb);
      }
 
      if( ProjectileIsAntiNucleus &&
            ( part == ANTIproton || part == ANTIneutron))
      {
         CanBeCapturedByProjectile = ExistProjectileRemnant &&
               (-CaptureThreshold*G4Log( G4UniformRand()) >
              (aTrack4Momentum       + Projectile4Momentum).mag() -
               aTrack4Momentum.mag() - Projectile4Momentum.mag())    &&
                   (Position.vect().mag() < Rb);
      }
 
      if(CanBeCapturedByTarget && CanBeCapturedByProjectile)
      {
         if(G4UniformRand() < 0.5)
         { CanBeCapturedByTarget = true; CanBeCapturedByProjectile = false;}
         else
         { CanBeCapturedByTarget = false; CanBeCapturedByProjectile = true;}
      }
 
      if(CanBeCapturedByTarget)
      {
         // within the target nucleus, neutron or proton
         // now calculate  A, Z of the fragment, momentum,
         // number of exciton states
#ifdef debugPrecoInt
         G4cout<<"Track is CapturedByTarget "<<" "<<part->GetParticleName()<<" "
               <<aTrack4Momentum<<" "<<aTrack4Momentum.mag()<<G4endl;
#endif
         ++anA;
         ++numberOfEx;
         G4int Z = G4int(part->GetPDGCharge()/eplus + 0.1);
         aZ += Z;
         numberOfCh += Z;
         Target4Momentum +=aTrack4Momentum;
         delete (*iter);
      } else if(CanBeCapturedByProjectile)
      {
         // within the projectile nucleus, neutron or proton
         // now calculate  A, Z of the fragment, momentum,
         // number of exciton states
#ifdef debugPrecoInt
         G4cout<<"Track is CapturedByProjectile"<<" "<<part->GetParticleName()<<" "
               <<aTrack4Momentum<<" "<<aTrack4Momentum.mag()<<G4endl;
#endif
         ++anAb;
         ++numberOfExB;
         G4int Z = G4int(part->GetPDGCharge()/eplus + 0.1);
         if( ProjectileIsAntiNucleus ) Z=-Z;
         aZb += Z;
         numberOfChB += Z;
         Projectile4Momentum +=aTrack4Momentum;
         delete (*iter);
      } else
      { // the track is not captured
         G4ReactionProduct * theNew = new G4ReactionProduct(part);
         theNew->SetMomentum(aTrack4Momentum.vect());
         theNew->SetTotalEnergy(aTrack4Momentum.e());
     theNew->SetCreatorModelID((*iter)->GetCreatorModelID());
         theTotalResult->push_back(theNew);
 
#ifdef debugPrecoInt
         SecondrNum++;
         secondary4Momemtum += (*iter)->Get4Momentum();
/*
         G4cout<<"Secondary  "<<SecondrNum<<" "
               <<theNew->GetDefinition()->GetParticleName()<<" "
               <<secondary4Momemtum<<G4endl;
*/
#endif
         delete (*iter);
         continue;
      }
   }
   delete theSecondaries;
   //-----------------------------------------------------
 
   #ifdef debugPrecoInt
   G4cout<<"Final target residual A Z (numberOfLambdas) E* 4mom "<<anA<<" "<<aZ<<" (0"//<<aL
        <<") "<<exEnergy<<" "<<Target4Momentum<<G4endl;
   #endif
 
   if(0!=anA )
   {
      // We assume that the target residual is never a hypernucleus
      G4double fMass =  G4NucleiProperties::GetNuclearMass(anA, aZ);
 
      if((anA == theNucleus->GetMassNumber()) && (exEnergy <= 0.))
      {Target4Momentum.setE(fMass);}
 
      G4double RemnMass=Target4Momentum.mag();
 
      if(RemnMass < fMass)
      {
         RemnMass=fMass + exEnergy;
         Target4Momentum.setE(std::sqrt(Target4Momentum.vect().mag2() +
               RemnMass*RemnMass));
      } else
      { exEnergy=RemnMass-fMass;}
 
      if( exEnergy < 0.) exEnergy=0.;
 
      // Need to de-excite the remnant nucleus
      G4Fragment anInitialState(anA, aZ, Target4Momentum);
      anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
      anInitialState.SetNumberOfCharged(numberOfCh);
      anInitialState.SetNumberOfHoles(numberOfHoles);
      anInitialState.SetCreatorModelID(secID);
 
      G4ReactionProductVector * aPrecoResult =
            theDeExcitation->DeExcite(anInitialState);
 
      #ifdef debugPrecoInt
         G4cout<<"Target fragment number "<<aPrecoResult->size()<<G4endl;
      #endif
 
      // fill pre-compound part into the result, and return
      for(unsigned int ll=0; ll<aPrecoResult->size(); ++ll)
      {
         theTotalResult->push_back(aPrecoResult->operator[](ll));
         #ifdef debugPrecoInt
            G4cout<<"Target fragment "<<ll<<" "
                  <<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()<<" "
                  <<aPrecoResult->operator[](ll)->GetMomentum()<<" "
                  <<aPrecoResult->operator[](ll)->GetTotalEnergy()<<" "
                  <<aPrecoResult->operator[](ll)->GetMass()<<G4endl;
         #endif
      }
      delete aPrecoResult;
   }
 
   //-----------------------------------------------------
   if((anAb == theProjectileNucleus->GetMassNumber())&& (exEnergyB <= 0.))
   {Projectile4Momentum = GetPrimaryProjectile()->Get4Momentum();}
 
   #ifdef debugPrecoInt
   G4cout<<"Final projectile residual A Z (numberOfLambdas) E* Pmom Pmag2 "<<anAb<<" "<<aZb<<" ("
     <<aLb<<") "<<exEnergyB<<" "<<Projectile4Momentum<<" "
                            <<Projectile4Momentum.mag2()<<G4endl;
   #endif
 
   if(0!=anAb)
   {
      // The projectile residual can be a hypernucleus or anti-hypernucleus
      G4double fMass = 0.0;
      if ( aLb > 0 ) {
    fMass = G4HyperNucleiProperties::GetNuclearMass(anAb, aZb, aLb);
      } else {
    fMass = G4NucleiProperties::GetNuclearMass(anAb, aZb);
      }        
      G4double RemnMass=Projectile4Momentum.mag();
 
      if(RemnMass < fMass)
      {
         RemnMass=fMass + exEnergyB;
         Projectile4Momentum.setE(std::sqrt(Projectile4Momentum.vect().mag2() +
               RemnMass*RemnMass));
      } else
      { exEnergyB=RemnMass-fMass;}
 
      if( exEnergyB < 0.) exEnergyB=0.;
 
      G4ThreeVector bstToCM =Projectile4Momentum.findBoostToCM();
      Projectile4Momentum.boost(bstToCM);
 
      // Need to de-excite the remnant nucleus
      G4Fragment anInitialState(anAb, aZb, aLb, Projectile4Momentum);
      anInitialState.SetNumberOfParticles(numberOfExB-numberOfHolesB);
      anInitialState.SetNumberOfCharged(numberOfChB);
      anInitialState.SetNumberOfHoles(numberOfHolesB);
      anInitialState.SetCreatorModelID(secID);
 
      G4ReactionProductVector * aPrecoResult =
            theDeExcitation->DeExcite(anInitialState);
 
      #ifdef debugPrecoInt
         G4cout<<"Projectile fragment number "<<aPrecoResult->size()<<G4endl;
      #endif
 
      // fill pre-compound part into the result, and return
      for(unsigned int ll=0; ll<aPrecoResult->size(); ++ll)
      {
         G4LorentzVector tmp=G4LorentzVector(aPrecoResult->operator[](ll)->GetMomentum(),
                                             aPrecoResult->operator[](ll)->GetTotalEnergy());
         tmp.boost(-bstToCM); // Transformation to the system of original remnant
         aPrecoResult->operator[](ll)->SetMomentum(tmp.vect());
         aPrecoResult->operator[](ll)->SetTotalEnergy(tmp.e());
 
         if(ProjectileIsAntiNucleus)
         {
            const G4ParticleDefinition * aFragment=aPrecoResult->operator[](ll)->GetDefinition();
            const G4ParticleDefinition * LastFragment=aFragment;
            if     (aFragment == proton)  {LastFragment=G4AntiProton::AntiProtonDefinition();}
            else if(aFragment == neutron) {LastFragment=G4AntiNeutron::AntiNeutronDefinition();}
            else if(aFragment == deuteron){LastFragment=G4AntiDeuteron::AntiDeuteronDefinition();}
            else if(aFragment == triton)  {LastFragment=G4AntiTriton::AntiTritonDefinition();}
            else if(aFragment == He3)     {LastFragment=G4AntiHe3::AntiHe3Definition();}
            else if(aFragment == He4)     {LastFragment=G4AntiAlpha::AntiAlphaDefinition();}
            else {}
 
            if (aLb > 0) {  // Anti-hypernucleus
          if        (aFragment == G4HyperTriton::Definition()) {
        LastFragment=G4AntiHyperTriton::Definition();
          } else if (aFragment == G4HyperH4::Definition()) {
        LastFragment=G4AntiHyperH4::Definition();
          } else if (aFragment == G4HyperAlpha::Definition()) {
        LastFragment=G4AntiHyperAlpha::Definition();
          } else if (aFragment == G4HyperHe5::Definition()) {
        LastFragment=G4AntiHyperHe5::Definition();
          } else if (aFragment == G4DoubleHyperH4::Definition()) {
        LastFragment=G4AntiDoubleHyperH4::Definition();
          } else if (aFragment == G4DoubleHyperDoubleNeutron::Definition()) {
        LastFragment=G4AntiDoubleHyperDoubleNeutron::Definition();
          }
        }
        
            aPrecoResult->operator[](ll)->SetDefinitionAndUpdateE(LastFragment);
         }
 
         #ifdef debugPrecoInt
            G4cout<<"Projectile fragment "<<ll<<" "
                  <<aPrecoResult->operator[](ll)->GetDefinition()->GetParticleName()<<" "
                  <<aPrecoResult->operator[](ll)->GetMomentum()<<" "
                  <<aPrecoResult->operator[](ll)->GetTotalEnergy()<<" "
                  <<aPrecoResult->operator[](ll)->GetMass()<<G4endl;
         #endif
 
         theTotalResult->push_back(aPrecoResult->operator[](ll));
      }
 
      delete aPrecoResult;
   }
 
   return theTotalResult;
}

References G4AntiAlpha::AntiAlphaDefinition(), G4AntiDeuteron::AntiDeuteronDefinition(), G4AntiHe3::AntiHe3Definition(), ANTIneutron, G4AntiNeutron::AntiNeutronDefinition(), ANTIproton, G4AntiProton::AntiProtonDefinition(), G4AntiTriton::AntiTritonDefinition(), G4Nucleon::AreYouHit(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), CaptureThreshold, G4INCL::ClusterDecay::decay(), G4VPreCompoundModel::DeExcite(), G4AntiLambda::Definition(), G4Lambda::Definition(), G4AntiDoubleHyperDoubleNeutron::Definition(), G4AntiDoubleHyperH4::Definition(), G4AntiHyperAlpha::Definition(), G4AntiHyperH4::Definition(), G4AntiHyperHe5::Definition(), G4AntiHyperTriton::Definition(), G4DoubleHyperDoubleNeutron::Definition(), G4DoubleHyperH4::Definition(), G4HyperAlpha::Definition(), G4HyperH4::Definition(), G4HyperHe5::Definition(), G4HyperTriton::Definition(), deuteron, CLHEP::HepLorentzVector::e(), eplus, CLHEP::HepLorentzVector::findBoostToCM(), G4cout, G4endl, G4Log(), G4UniformRand, G4HadProjectile::Get4Momentum(), G4Nucleon::Get4Momentum(), G4ParticleDefinition::GetBaryonNumber(), G4Nucleon::GetBindingEnergy(), G4V3DNucleus::GetCharge(), G4HadProjectile::GetDefinition(), G4Nucleon::GetDefinition(), G4ReactionProduct::GetDefinition(), G4V3DNucleus::GetMassNumber(), G4ReactionProduct::GetMomentum(), G4V3DNucleus::GetNextNucleon(), G4NucleiProperties::GetNuclearMass(), G4HyperNucleiProperties::GetNuclearMass(), G4V3DNucleus::GetNuclearRadius(), G4V3DNucleus::GetNumberOfLambdas(), G4ParticleDefinition::GetParticleName(), G4Nucleon::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4VIntraNuclearTransportModel::GetPrimaryProjectile(), G4ReactionProduct::GetTotalEnergy(), He3, He4, CLHEP::HepLorentzVector::mag(), CLHEP::HepLorentzVector::mag2(), CLHEP::Hep3Vector::mag2(), MakeCoalescence(), neutron, proton, secID, G4ReactionProduct::SetCreatorModelID(), G4Fragment::SetCreatorModelID(), CLHEP::HepLorentzVector::setE(), G4ReactionProduct::SetMomentum(), G4Fragment::SetNumberOfCharged(), G4Fragment::SetNumberOfHoles(), G4Fragment::SetNumberOfParticles(), G4ReactionProduct::SetTotalEnergy(), G4V3DNucleus::StartLoop(), G4VIntraNuclearTransportModel::theDeExcitation, triton, CLHEP::HepLorentzVector::vect(), and Z.

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.

SetCaptureThreshold()

void G4GeneratorPrecompoundInterface::SetCaptureThreshold ( G4double  value )

inline

Definition at line 116 of file G4GeneratorPrecompoundInterface.hh.

{
  CaptureThreshold = value;
}

References CaptureThreshold.

SetDeExcitation()

void G4VIntraNuclearTransportModel::SetDeExcitation ( G4VPreCompoundModel *  ptr )

inlineinherited

Definition at line 135 of file G4VIntraNuclearTransportModel.hh.

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

References G4VIntraNuclearTransportModel::theDeExcitation.

Referenced by G4BinaryCascade::G4BinaryCascade(), G4ElectroVDNuclearModel::G4ElectroVDNuclearModel(), G4GeneratorPrecompoundInterface(), G4MuonVDNuclearModel::G4MuonVDNuclearModel(), and G4NeutrinoNucleusModel::G4NeutrinoNucleusModel().

SetDeltaM()

void G4GeneratorPrecompoundInterface::SetDeltaM ( G4double  value )

inline

Definition at line 122 of file G4GeneratorPrecompoundInterface.hh.

{ 
  DeltaM = value;
}

References DeltaM.

SetDeltaR()

void G4GeneratorPrecompoundInterface::SetDeltaR ( G4double  value )

inline

Definition at line 128 of file G4GeneratorPrecompoundInterface.hh.

{ 
  DeltaR = value;
}

References DeltaR.

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

Field Documentation

ANTIdeuteron

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTIdeuteron

private

Definition at line 107 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface().

ANTIHe3

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTIHe3

private

Definition at line 109 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface().

ANTIHe4

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTIHe4

private

Definition at line 110 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface().

ANTIneutron

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTIneutron

private

Definition at line 105 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), and PropagateNuclNucl().

ANTIproton

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTIproton

private

Definition at line 104 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), and PropagateNuclNucl().

ANTItriton

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::ANTItriton

private

Definition at line 108 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface().

CaptureThreshold

G4double G4GeneratorPrecompoundInterface::CaptureThreshold

private

Definition at line 92 of file G4GeneratorPrecompoundInterface.hh.

Referenced by Propagate(), PropagateNuclNucl(), and SetCaptureThreshold().

DeltaM

G4double G4GeneratorPrecompoundInterface::DeltaM

private

Definition at line 93 of file G4GeneratorPrecompoundInterface.hh.

Referenced by MakeCoalescence(), and SetDeltaM().

DeltaR

G4double G4GeneratorPrecompoundInterface::DeltaR

private

Definition at line 94 of file G4GeneratorPrecompoundInterface.hh.

Referenced by SetDeltaR().

deuteron

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::deuteron

private

Definition at line 99 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), MakeCoalescence(), and PropagateNuclNucl().

epCheckLevels

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

privateinherited

Definition at line 198 of file G4HadronicInteraction.hh.

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

He3

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::He3

private

Definition at line 101 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), and PropagateNuclNucl().

He4

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::He4

private

Definition at line 102 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), and PropagateNuclNucl().

isBlocked

G4bool G4HadronicInteraction::isBlocked

protectedinherited

Definition at line 188 of file G4HadronicInteraction.hh.

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

neutron

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::neutron

private

Definition at line 97 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), MakeCoalescence(), Propagate(), and PropagateNuclNucl().

proton

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::proton

private

Definition at line 96 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), MakeCoalescence(), Propagate(), and PropagateNuclNucl().

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 G4GeneratorPrecompoundInterface::secID

private

Definition at line 112 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), MakeCoalescence(), Propagate(), and PropagateNuclNucl().

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

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(), G4INCLXXInterface::ApplyYourself(), G4BinaryCascade::DeExcite(), G4INCLXXInterface::G4INCLXXInterface(), G4VIntraNuclearTransportModel::GetDeExcitation(), G4INCLXXInterface::GetDeExcitationModelName(), G4BinaryCascade::ModelDescription(), Propagate(), G4BinaryCascade::PropagateModelDescription(), PropagateNuclNucl(), and G4VIntraNuclearTransportModel::SetDeExcitation().

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

thePrimaryProjectile

const G4HadProjectile* G4VIntraNuclearTransportModel::thePrimaryProjectile

protectedinherited

Definition at line 111 of file G4VIntraNuclearTransportModel.hh.

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

theTransportModelName

G4String G4VIntraNuclearTransportModel::theTransportModelName

protectedinherited

Definition at line 105 of file G4VIntraNuclearTransportModel.hh.

Referenced by G4VIntraNuclearTransportModel::GetModelName().

triton

const G4ParticleDefinition* G4GeneratorPrecompoundInterface::triton

private

Definition at line 100 of file G4GeneratorPrecompoundInterface.hh.

Referenced by G4GeneratorPrecompoundInterface(), and PropagateNuclNucl().

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/binary_cascade/include/G4GeneratorPrecompoundInterface.hh
• source/processes/hadronic/models/binary_cascade/src/G4GeneratorPrecompoundInterface.cc