G4HadronicProcess Class Reference

#include <G4HadronicProcess.hh>

Inheritance diagram for G4HadronicProcess:

Public Member Functions
	G4HadronicProcess (const G4String &processName="Hadronic", G4ProcessType procType=fHadronic)
	G4HadronicProcess (const G4String &processName, G4HadronicProcessType subType)
virtual	~G4HadronicProcess ()
void	RegisterMe (G4HadronicInteraction *a)
G4double	GetElementCrossSection (const G4DynamicParticle *part, const G4Element *elm, const G4Material *mat=0)
G4double	GetMicroscopicCrossSection (const G4DynamicParticle *part, const G4Element *elm, const G4Material *mat=0)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DumpPhysicsTable (const G4ParticleDefinition &p)
void	AddDataSet (G4VCrossSectionDataSet *aDataSet)
G4EnergyRangeManager *	GetManagerPointer ()
G4double	GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *)
const G4Nucleus *	GetTargetNucleus () const
const G4Isotope *	GetTargetIsotope ()
virtual void	ProcessDescription (std::ostream &outFile) const
void	BiasCrossSectionByFactor (G4double aScale)
void	SetEpReportLevel (G4int level)
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
G4CrossSectionDataStore *	GetCrossSectionDataStore ()
void	MultiplyCrossSectionBy (G4double factor)
Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)
	G4VDiscreteProcess (G4VDiscreteProcess &)
virtual	~G4VDiscreteProcess ()
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4int	operator== (const G4VProcess &right) const
G4int	operator!= (const G4VProcess &right) const
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Protected Member Functions
G4HadronicInteraction *	ChooseHadronicInteraction (G4double kineticEnergy, G4Material *aMaterial, G4Element *anElement)
G4Nucleus *	GetTargetNucleusPointer ()
void	DumpState (const G4Track &, const G4String &, G4ExceptionDescription &)
const G4EnergyRangeManager &	GetEnergyRangeManager () const
void	SetEnergyRangeManager (const G4EnergyRangeManager &value)
G4HadronicInteraction *	GetHadronicInteraction () const
G4double	GetLastCrossSection ()
void	FillResult (G4HadFinalState *aR, const G4Track &aT)
G4HadFinalState *	CheckResult (const G4HadProjectile &thePro, const G4Nucleus &targetNucleus, G4HadFinalState *result) const
void	CheckEnergyMomentumConservation (const G4Track &, const G4Nucleus &)
virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4HadProjectile	thePro
G4ParticleChange *	theTotalResult
G4int	epReportLevel
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager
G4VParticleChange *	pParticleChange
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft
G4double	currentInteractionLength
G4double	theInitialNumberOfInteractionLength
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType
G4int	theProcessSubType
G4double	thePILfactor
G4bool	enableAtRestDoIt
G4bool	enableAlongStepDoIt
G4bool	enablePostStepDoIt
G4int	verboseLevel

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 69 of file G4HadronicProcess.hh.

Constructor & Destructor Documentation

G4HadronicProcess() [1/2]

G4HadronicProcess::G4HadronicProcess	(	const G4String &	processName = "Hadronic",
		G4ProcessType	procType = fHadronic
	)

Definition at line 83 of file G4HadronicProcess.cc.

 : G4VDiscreteProcess(processName, procType)
{
  SetProcessSubType(fHadronInelastic);  // Default unless subclass changes
  
  theTotalResult = new G4ParticleChange();
  theTotalResult->SetSecondaryWeightByProcess(true);
  theInteraction = 0;
  theCrossSectionDataStore = new G4CrossSectionDataStore();
  G4HadronicProcessStore::Instance()->Register(this);
  aScaleFactor = 1;
  xBiasOn = false;
  G4HadronicProcess_debug_flag = false;
 
  GetEnergyMomentumCheckEnvvars();
}

G4HadronicProcess() [2/2]

G4HadronicProcess::G4HadronicProcess	(	const G4String &	processName,
		G4HadronicProcessType	subType
	)

Definition at line 103 of file G4HadronicProcess.cc.

 : G4VDiscreteProcess(processName, fHadronic)
{
  SetProcessSubType(aHadSubType);
 
  theTotalResult = new G4ParticleChange();
  theTotalResult->SetSecondaryWeightByProcess(true);
  theInteraction = 0;
  theCrossSectionDataStore = new G4CrossSectionDataStore();
  G4HadronicProcessStore::Instance()->Register(this);
  aScaleFactor = 1;
  xBiasOn = false;
  G4HadronicProcess_debug_flag = false;
 
  GetEnergyMomentumCheckEnvvars();
}

~G4HadronicProcess()

G4HadronicProcess::~G4HadronicProcess ( )

virtual

Definition at line 122 of file G4HadronicProcess.cc.

{
  G4HadronicProcessStore::Instance()->DeRegister(this);
  delete theTotalResult;
  delete theCrossSectionDataStore;
}

Member Function Documentation

AddDataSet()

void G4HadronicProcess::AddDataSet ( G4VCrossSectionDataSet *  aDataSet )

inline

Definition at line 117 of file G4HadronicProcess.hh.

  { theCrossSectionDataStore->AddDataSet(aDataSet);}

Referenced by G4VHadronPhysics::AddCaptureCrossSection(), G4VHadronPhysics::AddElasticCrossSection(), G4VHadronPhysics::AddFissionCrossSection(), G4VHadronPhysics::AddInelasticCrossSection(), G4HadronElasticPhysicsXS::AddXSection(), G4HyperonFTFPBuilder::Build(), G4MiscBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4NeutronHPBuilder::Build(), G4NeutronLENDBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFCNeutronBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSC_CHIPSNeutronBuilder::Build(), G4QGSC_QGSCNeutronBuilder::Build(), G4QGSCEflowNeutronBuilder::Build(), G4QGSCNeutronBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4INCLXXPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFCPiKBuilder::Build(), G4FTFPPiKBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSC_CHIPSPiKBuilder::Build(), G4QGSC_QGSCPiKBuilder::Build(), G4QGSCEflowPiKBuilder::Build(), G4QGSCPiKBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFCProtonBuilder::Build(), G4FTFPProtonBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4PrecoProtonBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSC_CHIPSProtonBuilder::Build(), G4QGSC_QGSCProtonBuilder::Build(), G4QGSCEflowProtonBuilder::Build(), G4QGSCProtonBuilder::Build(), G4QGSPProtonBuilder::Build(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronQElasticPhysics::ConstructProcess(), G4NeutronCrossSectionXS::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), HadronPhysicsFTFP_BERT::ConstructProcess(), HadronPhysicsFTFP_BERT_HP::ConstructProcess(), HadronPhysicsFTFP_BERT_TRV::ConstructProcess(), HadronPhysicsQGSP_BERT_95::ConstructProcess(), HadronPhysicsQGSP_BERT_CHIPS::ConstructProcess(), HadronPhysicsQGSP_FTFP_BERT_95::ConstructProcess(), HadronPhysicsShielding::ConstructProcess(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4HadronCaptureProcess::G4HadronCaptureProcess(), G4HadronElasticProcess::G4HadronElasticProcess(), G4HadronFissionProcess::G4HadronFissionProcess(), G4HadronInelasticProcess::G4HadronInelasticProcess(), G4MuonNuclearProcess::G4MuonNuclearProcess(), and G4WHadronElasticProcess::G4WHadronElasticProcess().

BiasCrossSectionByFactor()

void G4HadronicProcess::BiasCrossSectionByFactor

(

G4double

aScale

)

Definition at line 605 of file G4HadronicProcess.cc.

{
  xBiasOn = true;
  aScaleFactor = aScale;
  G4String it = GetProcessName();
  if( (it != "PhotonInelastic") &&
      (it != "ElectroNuclear") &&
      (it != "PositronNuclear") )
    {
      G4ExceptionDescription ed;
      G4Exception("G4HadronicProcess::BiasCrossSectionByFactor", "had009", FatalException, ed,
          "Cross-section biasing available only for gamma and electro nuclear reactions.");
    }
  if(aScale<100)
    {
      G4ExceptionDescription ed;
      G4Exception("G4HadronicProcess::BiasCrossSectionByFactor", "had010", JustWarning,ed,
          "Cross-section bias readjusted to be above safe limit. New value is 100");
      aScaleFactor = 100.;
    }
}

BuildPhysicsTable()

void G4HadronicProcess::BuildPhysicsTable ( const G4ParticleDefinition &  p )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4ChargeExchangeProcess.

Definition at line 166 of file G4HadronicProcess.cc.

{
  try
  {
    theCrossSectionDataStore->BuildPhysicsTable(p);
  }
  catch(G4HadronicException aR)
  {
    G4ExceptionDescription ed;
    aR.Report(ed);
    ed << " hadronic initialisation fails" << G4endl;
    G4Exception("G4HadronicProcess::BuildPhysicsTable", "had000", 
        FatalException,ed);
  }
  G4HadronicProcessStore::Instance()->PrintInfo(&p);
}

Referenced by G4ChargeExchangeProcess::BuildPhysicsTable().

CheckEnergyMomentumConservation()

void G4HadronicProcess::CheckEnergyMomentumConservation ( const G4Track &  aTrack, const G4Nucleus &  aNucleus  )

protected

Definition at line 677 of file G4HadronicProcess.cc.

{
  G4int target_A=aNucleus.GetA_asInt();
  G4int target_Z=aNucleus.GetZ_asInt();
  G4double targetMass = G4NucleiProperties::GetNuclearMass(target_A,target_Z);
  G4LorentzVector target4mom(0, 0, 0, targetMass);
 
  G4LorentzVector projectile4mom = aTrack.GetDynamicParticle()->Get4Momentum();
  G4int track_A = aTrack.GetDefinition()->GetBaryonNumber();
  G4int track_Z = G4lrint(aTrack.GetDefinition()->GetPDGCharge());
 
  G4int initial_A = target_A + track_A;
  G4int initial_Z = target_Z + track_Z;
 
  G4LorentzVector initial4mom = projectile4mom + target4mom;
 
  // Compute final-state momentum for scattering and "do nothing" results
  G4LorentzVector final4mom;
  G4int final_A(0), final_Z(0);
 
  G4int nSec = theTotalResult->GetNumberOfSecondaries();
  if (theTotalResult->GetTrackStatus() != fStopAndKill) {  // If it is Alive
     // Either interaction didn't complete, returned "do nothing" state
     //  or    the primary survived the interaction (e.g. electro-nucleus )
     G4Track temp(aTrack);
 
     // Use the final energy / momentum
     temp.SetMomentumDirection(*theTotalResult->GetMomentumDirection());
     temp.SetKineticEnergy(theTotalResult->GetEnergy());
 
     if( nSec == 0 ){
        // Interaction didn't complete, returned "do nothing" state
        //   - or suppressed recoil  (e.g. Neutron elastic )
        final4mom = temp.GetDynamicParticle()->Get4Momentum() + target4mom;
        final_A = initial_A;
        final_Z = initial_Z;
     }else{
        // The primary remains in final state (e.g. electro-nucleus )
        final4mom = temp.GetDynamicParticle()->Get4Momentum();
        final_A = track_A;
        final_Z = track_Z;
        // Expect that the target nucleus will have interacted,
        //  and its products, including recoil, will be included in secondaries.
     }
  }
  if( nSec > 0 ) {
    G4Track* sec;
 
    for (G4int i = 0; i < nSec; i++) {
      sec = theTotalResult->GetSecondary(i);
      final4mom += sec->GetDynamicParticle()->Get4Momentum();
      final_A += sec->GetDefinition()->GetBaryonNumber();
      final_Z += G4lrint(sec->GetDefinition()->GetPDGCharge());
    }
  }
 
  // Get level-checking information (used to cut-off relative checks)
  G4String processName = GetProcessName();
  G4HadronicInteraction* theModel = GetHadronicInteraction();
  G4String modelName("none");
  if (theModel) modelName = theModel->GetModelName();
  std::pair<G4double, G4double> checkLevels = epCheckLevels;
  if (!levelsSetByProcess) {
    if (theModel) checkLevels = theModel->GetEnergyMomentumCheckLevels();
    checkLevels.first= std::min(checkLevels.first,  epCheckLevels.first);
    checkLevels.second=std::min(checkLevels.second, epCheckLevels.second);
  }
 
  // Compute absolute total-energy difference, and relative kinetic-energy
  G4bool checkRelative = (aTrack.GetKineticEnergy() > checkLevels.second);
 
  G4LorentzVector diff = initial4mom - final4mom;
  G4double absolute = diff.e();
  G4double relative = checkRelative ? absolute/aTrack.GetKineticEnergy() : 0.;
 
  G4double absolute_mom = diff.vect().mag();
  G4double relative_mom = checkRelative ? absolute_mom/aTrack.GetMomentum().mag() : 0.;
 
  // Evaluate relative and absolute conservation
  G4bool relPass = true;
  G4String relResult = "pass";
  if (  std::abs(relative) > checkLevels.first
     || std::abs(relative_mom) > checkLevels.first) {
    relPass = false;
    relResult = checkRelative ? "fail" : "N/A";
  }
 
  G4bool absPass = true;
  G4String absResult = "pass";
  if (   std::abs(absolute) > checkLevels.second
      || std::abs(absolute_mom) > checkLevels.second ) {
    absPass = false ;
    absResult = "fail";
  }
 
  G4bool chargePass = true;
  G4String chargeResult = "pass";
  if (   (initial_A-final_A)!=0
      || (initial_Z-final_Z)!=0 ) {
    chargePass = checkLevels.second < DBL_MAX ? false : true;
    chargeResult = "fail";
   }
 
  G4bool conservationPass = (relPass || absPass) && chargePass;
 
  std::stringstream Myout;
  G4bool Myout_notempty(false);
  // Options for level of reporting detail:
  //  0. off
  //  1. report only when E/p not conserved
  //  2. report regardless of E/p conservation
  //  3. report only when E/p not conserved, with model names, process names, and limits
  //  4. report regardless of E/p conservation, with model names, process names, and limits
  //  negative -1.., as above, but send output to stderr
 
  if(   std::abs(epReportLevel) == 4
    ||  ( std::abs(epReportLevel) == 3 && ! conservationPass ) ){
      Myout << " Process: " << processName << " , Model: " <<  modelName << G4endl;
      Myout << " Primary: " << aTrack.GetParticleDefinition()->GetParticleName()
            << " (" << aTrack.GetParticleDefinition()->GetPDGEncoding() << "),"
            << " E= " <<  aTrack.GetDynamicParticle()->Get4Momentum().e()
        << ", target nucleus (" << aNucleus.GetZ_asInt() << ","
        << aNucleus.GetA_asInt() << ")" << G4endl;
      Myout_notempty=true;
  }
  if (  std::abs(epReportLevel) == 4
     || std::abs(epReportLevel) == 2
     || ! conservationPass ){
 
      Myout << "   "<< relResult  <<" relative, limit " << checkLevels.first << ", values E/T(0) = "
             << relative << " p/p(0)= " << relative_mom  << G4endl;
      Myout << "   "<< absResult << " absolute, limit (MeV) " << checkLevels.second/MeV << ", values E / p (MeV) = "
             << absolute/MeV << " / " << absolute_mom/MeV << G4endl;
      Myout << "   "<< chargeResult << " charge/baryon number balance " << (initial_Z-final_Z) << " / " << (initial_A-final_A) << " "<<  G4endl;
      Myout_notempty=true;
 
  }
  Myout.flush();
  if ( Myout_notempty ) {
     if (epReportLevel > 0)      G4cout << Myout.str()<< G4endl;
     else if (epReportLevel < 0) G4cerr << Myout.str()<< G4endl;
  }
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), and PostStepDoIt().

CheckResult()

G4HadFinalState * G4HadronicProcess::CheckResult ( const G4HadProjectile &  thePro, const G4Nucleus &  targetNucleus, G4HadFinalState *  result  ) const

protected

Definition at line 627 of file G4HadronicProcess.cc.

{
   // check for catastrophic energy non-conservation, to re-sample the interaction
 
   G4HadronicInteraction * theModel = GetHadronicInteraction();
   G4double nuclearMass(0);
   if (theModel){
 
      // Compute final-state total energy
      G4double finalE(0.);
      G4int nSec = result->GetNumberOfSecondaries();
 
      nuclearMass = G4NucleiProperties::GetNuclearMass(aNucleus.GetA_asInt(),
                                                       aNucleus.GetZ_asInt());
      if (result->GetStatusChange() != stopAndKill) {
        // Interaction didn't complete, returned "do nothing" state          => reset nucleus
        //  or  the primary survived the interaction (e.g. electro-nuclear ) => keep  nucleus
         finalE=result->GetLocalEnergyDeposit() +
        aPro.GetDefinition()->GetPDGMass() + result->GetEnergyChange();
         if( nSec == 0 ){
            // Since there are no secondaries, there is no recoil nucleus.
            // To check energy balance we must neglect the initial nucleus too.
            nuclearMass=0.0;
         }
      }
      for (G4int i = 0; i < nSec; i++) {
         finalE += result->GetSecondary(i)->GetParticle()->GetTotalEnergy();
      }
      G4double deltaE= nuclearMass +  aPro.GetTotalEnergy() -  finalE;
 
      std::pair<G4double, G4double> checkLevels = theModel->GetFatalEnergyCheckLevels();    // (relative, absolute)
      if (std::abs(deltaE) > checkLevels.second && std::abs(deltaE) > checkLevels.first*aPro.GetKineticEnergy()){
         // do not delete result, this is a pointer to a data member;
         result=0;
         G4ExceptionDescription desc;
         desc << "Warning: Bad energy non-conservation detected, will "
              << (epReportLevel<0 ? "abort the event" : "re-sample the interaction") << G4endl
              << " Process / Model: " <<  GetProcessName()<< " / " << theModel->GetModelName() << G4endl
              << " Primary: " << aPro.GetDefinition()->GetParticleName()
              << " (" << aPro.GetDefinition()->GetPDGEncoding() << "),"
              << " E= " <<  aPro.Get4Momentum().e()
              << ", target nucleus (" << aNucleus.GetZ_asInt() << ","<< aNucleus.GetA_asInt() << ")" << G4endl
              << " E(initial - final) = " << deltaE << " MeV." << G4endl;
         G4Exception("G4HadronicProcess:CheckResult()", "had012", epReportLevel<0 ? EventMustBeAborted : JustWarning,desc);
      }
   }
   return result;
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), and PostStepDoIt().

ChooseHadronicInteraction()

G4HadronicInteraction * G4HadronicProcess::ChooseHadronicInteraction ( G4double  kineticEnergy, G4Material *  aMaterial, G4Element *  anElement  )

inlineprotected

Definition at line 142 of file G4HadronicProcess.hh.

  { return theEnergyRangeManager.GetHadronicInteraction(kineticEnergy,
                            aMaterial,anElement);
  }

Referenced by G4HadronStoppingProcess::AtRestDoIt(), PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4WHadronElasticProcess::PostStepDoIt().

DumpPhysicsTable()

void G4HadronicProcess::DumpPhysicsTable ( const G4ParticleDefinition &  p )

inline

Definition at line 113 of file G4HadronicProcess.hh.

  { theCrossSectionDataStore->DumpPhysicsTable(p); }

DumpState()

void G4HadronicProcess::DumpState ( const G4Track &  aTrack, const G4String &  method, G4ExceptionDescription &  ed  )

protected

Definition at line 823 of file G4HadronicProcess.cc.

{
  ed << "Unrecoverable error in the method " << method << " of "
     << GetProcessName() << G4endl;
  ed << "TrackID= "<< aTrack.GetTrackID() << "  ParentID= "
     << aTrack.GetParentID()
     << "  " << aTrack.GetParticleDefinition()->GetParticleName()
     << G4endl;
  ed << "Ekin(GeV)= " << aTrack.GetKineticEnergy()/CLHEP::GeV
     << ";  direction= " << aTrack.GetMomentumDirection() << G4endl;
  ed << "Position(mm)= " << aTrack.GetPosition()/CLHEP::mm << ";";
 
  if (aTrack.GetMaterial()) {
    ed << "  material " << aTrack.GetMaterial()->GetName();
  }
  ed << G4endl;
 
  if (aTrack.GetVolume()) {
    ed << "PhysicalVolume  <" << aTrack.GetVolume()->GetName()
       << ">" << G4endl;
  }
}

Referenced by G4HadronStoppingProcess::AtRestDoIt(), FillResult(), GetMeanFreePath(), PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4WHadronElasticProcess::PostStepDoIt().

FillResult()

void G4HadronicProcess::FillResult ( G4HadFinalState *  aR, const G4Track &  aT  )

protected

Definition at line 376 of file G4HadronicProcess.cc.

{
  theTotalResult->ProposeLocalEnergyDeposit(aR->GetLocalEnergyDeposit());
 
  G4double rotation = CLHEP::twopi*G4UniformRand();
  G4ThreeVector it(0., 0., 1.);
 
  G4double efinal = aR->GetEnergyChange();
  if(efinal < 0.0) { efinal = 0.0; }
 
  // check status of primary
  if(aR->GetStatusChange() == stopAndKill) {
    theTotalResult->ProposeTrackStatus(fStopAndKill);
    theTotalResult->ProposeEnergy( 0.0 );
 
    // check its final energy
  } else if(0.0 == efinal) {
    theTotalResult->ProposeEnergy( 0.0 );
    if(aT.GetParticleDefinition()->GetProcessManager()
       ->GetAtRestProcessVector()->size() > 0)
         { aParticleChange.ProposeTrackStatus(fStopButAlive); }
    else { aParticleChange.ProposeTrackStatus(fStopAndKill); }
 
    // primary is not killed apply rotation and Lorentz transformation
  } else  {
    theTotalResult->ProposeTrackStatus(fAlive);
    G4double mass = aT.GetParticleDefinition()->GetPDGMass();
    G4double newE = efinal + mass;
    G4double newP = std::sqrt(efinal*(efinal + 2*mass));
    G4ThreeVector newPV = newP*aR->GetMomentumChange();
    G4LorentzVector newP4(newE, newPV);
    newP4.rotate(rotation, it);
    newP4 *= aR->GetTrafoToLab();
    theTotalResult->ProposeMomentumDirection(newP4.vect().unit());
    newE = newP4.e() - mass;
    if(G4HadronicProcess_debug_flag && newE <= 0.0) {
      G4ExceptionDescription ed;
      DumpState(aT,"Primary has zero energy after interaction",ed);
      G4Exception("G4HadronicProcess::FillResults", "had011", JustWarning, ed);
    }
    if(newE < 0.0) { newE = 0.0; }
    theTotalResult->ProposeEnergy( newE );
  }
 
  // check secondaries: apply rotation and Lorentz transformation
  G4int nSec = aR->GetNumberOfSecondaries();
  theTotalResult->SetNumberOfSecondaries(nSec);
  G4double weight = aT.GetWeight();
 
  if (nSec > 0) {
    G4double time0 = aT.GetGlobalTime();
    for (G4int i = 0; i < nSec; ++i) {
      G4LorentzVector theM = aR->GetSecondary(i)->GetParticle()->Get4Momentum();
      theM.rotate(rotation, it);
      theM *= aR->GetTrafoToLab();
      aR->GetSecondary(i)->GetParticle()->Set4Momentum(theM);
 
      // time of interaction starts from zero
      G4double time = aR->GetSecondary(i)->GetTime();
      if (time < 0.0) { time = 0.0; }
 
      // take into account global time
      time += time0;
 
      G4Track* track = new G4Track(aR->GetSecondary(i)->GetParticle(),
                                   time, aT.GetPosition());
      G4double newWeight = weight*aR->GetSecondary(i)->GetWeight();
    // G4cout << "#### ParticleDebug "
    // <<GetProcessName()<<" "
    // <<aR->GetSecondary(i)->GetParticle()->GetDefinition()->GetParticleName()<<" "
    // <<aScaleFactor<<" "
    // <<XBiasSurvivalProbability()<<" "
    // <<XBiasSecondaryWeight()<<" "
    // <<aT.GetWeight()<<" "
    // <<aR->GetSecondary(i)->GetWeight()<<" "
    // <<aR->GetSecondary(i)->GetParticle()->Get4Momentum()<<" "
    // <<G4endl;
      track->SetWeight(newWeight);
      track->SetTouchableHandle(aT.GetTouchableHandle());
      theTotalResult->AddSecondary(track);
      if (G4HadronicProcess_debug_flag) {
        G4double e = track->GetKineticEnergy();
        if (e <= 0.0) {
          G4ExceptionDescription ed;
          DumpState(aT,"Secondary has zero energy",ed);
          ed << "Secondary " << track->GetDefinition()->GetParticleName()
             << G4endl;
          G4Exception("G4HadronicProcess::FillResults", "had011", JustWarning,ed);
        }
      }
    }
  }
 
  aR->Clear();
  return;
}

Referenced by PostStepDoIt().

GetCrossSectionDataStore()

G4CrossSectionDataStore * G4HadronicProcess::GetCrossSectionDataStore ( )

inline

Definition at line 170 of file G4HadronicProcess.hh.

    {return theCrossSectionDataStore;}

Referenced by G4ChargeExchangeProcess::BuildPhysicsTable(), G4ElectronNuclearProcess::G4ElectronNuclearProcess(), G4PhotoNuclearProcess::G4PhotoNuclearProcess(), G4PositronNuclearProcess::G4PositronNuclearProcess(), G4HadronElasticProcess::PostStepDoIt(), G4WHadronElasticProcess::PostStepDoIt(), and G4HadronicProcessStore::PrintHtml().

GetElementCrossSection()

G4double G4HadronicProcess::GetElementCrossSection ( const G4DynamicParticle *  part, const G4Element *  elm, const G4Material *  mat = 0  )

inline

Definition at line 86 of file G4HadronicProcess.hh.

  {
    G4double x = theCrossSectionDataStore->GetCrossSection(part, elm, mat);
    if(x < 0.0) { x = 0.0; }
    return x;
  }

Referenced by G4HadronicProcessStore::GetCaptureCrossSectionPerAtom(), G4HadronicProcessStore::GetChargeExchangeCrossSectionPerAtom(), G4HadronicProcessStore::GetElasticCrossSectionPerAtom(), G4HadronicProcessStore::GetFissionCrossSectionPerAtom(), G4HadronicProcessStore::GetInelasticCrossSectionPerAtom(), GetMicroscopicCrossSection(), and PostStepDoIt().

GetEnergyMomentumCheckLevels()

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

inline

Definition at line 166 of file G4HadronicProcess.hh.

  { return epCheckLevels; }

Referenced by G4HadronicProcessStore::SetProcessAbsLevel(), and G4HadronicProcessStore::SetProcessRelLevel().

GetEnergyRangeManager()

const G4EnergyRangeManager & G4HadronicProcess::GetEnergyRangeManager ( ) const

inlineprotected

Definition at line 181 of file G4HadronicProcess.hh.

  { return theEnergyRangeManager; }

GetHadronicInteraction()

G4HadronicInteraction * G4HadronicProcess::GetHadronicInteraction ( ) const

inlineprotected

Definition at line 189 of file G4HadronicProcess.hh.

  { return theInteraction; }

Referenced by CheckEnergyMomentumConservation(), and CheckResult().

GetLastCrossSection()

G4double G4HadronicProcess::GetLastCrossSection ( )

inlineprotected

Definition at line 193 of file G4HadronicProcess.hh.

  { return theLastCrossSection; }

GetManagerPointer()

G4EnergyRangeManager * G4HadronicProcess::GetManagerPointer ( )

inline

Definition at line 121 of file G4HadronicProcess.hh.

  { return &theEnergyRangeManager; }

Referenced by RegisterMe().

GetMeanFreePath()

G4double G4HadronicProcess::GetMeanFreePath ( const G4Track &  aTrack, G4double  , G4ForceCondition *    )

virtual

Implements G4VDiscreteProcess.

Definition at line 183 of file G4HadronicProcess.cc.

{
  try
  {
    theLastCrossSection = aScaleFactor*
      theCrossSectionDataStore->GetCrossSection(aTrack.GetDynamicParticle(),
                        aTrack.GetMaterial());
  }
  catch(G4HadronicException aR)
  {
    G4ExceptionDescription ed;
    aR.Report(ed);
    DumpState(aTrack,"GetMeanFreePath",ed);
    ed << " Cross section is not available" << G4endl;
    G4Exception("G4HadronicProcess::GetMeanFreePath", "had002", FatalException,
        ed);
  }
  G4double res = DBL_MAX;
  if( theLastCrossSection > 0.0 ) { res = 1.0/theLastCrossSection; }
  return res;
}

GetMicroscopicCrossSection()

G4double G4HadronicProcess::GetMicroscopicCrossSection ( const G4DynamicParticle *  part, const G4Element *  elm, const G4Material *  mat = 0  )

inline

Definition at line 97 of file G4HadronicProcess.hh.

  { return GetElementCrossSection(part, elm, mat); }

GetTargetIsotope()

const G4Isotope * G4HadronicProcess::GetTargetIsotope ( )

inline

Definition at line 133 of file G4HadronicProcess.hh.

  { return targetNucleus.GetIsotope(); }

GetTargetNucleus()

const G4Nucleus * G4HadronicProcess::GetTargetNucleus ( ) const

inline

Definition at line 129 of file G4HadronicProcess.hh.

  { return &targetNucleus; }

GetTargetNucleusPointer()

G4Nucleus * G4HadronicProcess::GetTargetNucleusPointer ( )

inlineprotected

Definition at line 149 of file G4HadronicProcess.hh.

  { return &targetNucleus; }

Referenced by G4HadronStoppingProcess::AtRestDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4WHadronElasticProcess::PostStepDoIt().

MultiplyCrossSectionBy()

void G4HadronicProcess::MultiplyCrossSectionBy ( G4double  factor )

inline

Definition at line 173 of file G4HadronicProcess.hh.

  { aScaleFactor = factor; }

PostStepDoIt()

G4VParticleChange * G4HadronicProcess::PostStepDoIt ( const G4Track &  aTrack, const G4Step &  aStep  )

virtual

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4HadronElasticProcess, and G4WHadronElasticProcess.

Definition at line 207 of file G4HadronicProcess.cc.

{
  // if primary is not Alive then do nothing
  theTotalResult->Clear();
  theTotalResult->Initialize(aTrack);
  theTotalResult->ProposeWeight(aTrack.GetWeight());
  if(aTrack.GetTrackStatus() != fAlive) { return theTotalResult; }
 
  // Find cross section at end of step and check if <= 0
  //
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  G4Material* aMaterial = aTrack.GetMaterial();
 
  G4Element* anElement = 0;
  try
  {
     anElement = theCrossSectionDataStore->SampleZandA(aParticle,
                               aMaterial,
                               targetNucleus);
  }
  catch(G4HadronicException & aR)
  {
    G4ExceptionDescription ed;
    aR.Report(ed);
    DumpState(aTrack,"SampleZandA",ed);
    ed << " PostStepDoIt failed on element selection" << G4endl;
    G4Exception("G4HadronicProcess::PostStepDoIt", "had003", FatalException,
        ed);
  }
 
  // check only for charged particles
  if(aParticle->GetDefinition()->GetPDGCharge() != 0.0) {
    if (GetElementCrossSection(aParticle, anElement, aMaterial) <= 0.0) {
      // No interaction
      return theTotalResult;
    }    
  }
 
  // Next check for illegal track status
  //
  if (aTrack.GetTrackStatus() != fAlive && aTrack.GetTrackStatus() != fSuspend) {
    if (aTrack.GetTrackStatus() == fStopAndKill ||
        aTrack.GetTrackStatus() == fKillTrackAndSecondaries ||
        aTrack.GetTrackStatus() == fPostponeToNextEvent) {
      G4ExceptionDescription ed;
      ed << "G4HadronicProcess: track in unusable state - "
     << aTrack.GetTrackStatus() << G4endl;
      ed << "G4HadronicProcess: returning unchanged track " << G4endl;
      DumpState(aTrack,"PostStepDoIt",ed);
      G4Exception("G4HadronicProcess::PostStepDoIt", "had004", JustWarning, ed);
    }
    // No warning for fStopButAlive which is a legal status here
    return theTotalResult;
  }
 
  // Go on to regular case
  //
  G4double originalEnergy = aParticle->GetKineticEnergy();
  G4double kineticEnergy = originalEnergy;
 
  // Get kinetic energy per nucleon for ions
  if(aParticle->GetParticleDefinition()->GetBaryonNumber() > 1.5)
          kineticEnergy/=aParticle->GetParticleDefinition()->GetBaryonNumber();
 
  try
  {
    theInteraction =
      ChooseHadronicInteraction( kineticEnergy, aMaterial, anElement );
  }
  catch(G4HadronicException & aE)
  {
    G4ExceptionDescription ed;
    aE.Report(ed);
    ed << "Target element "<<anElement->GetName()<<"  Z= "
       << targetNucleus.GetZ_asInt() << "  A= "
       << targetNucleus.GetA_asInt() << G4endl;
    DumpState(aTrack,"ChooseHadronicInteraction",ed);
    ed << " No HadronicInteraction found out" << G4endl;
    G4Exception("G4HadronicProcess::PostStepDoIt", "had005", FatalException,
        ed);
  }
 
  // Initialize the hadronic projectile from the track
  thePro.Initialise(aTrack);
  G4HadFinalState* result = 0;
  G4int reentryCount = 0;
 
  do
  {
    try
    {
      // Save random engine if requested for debugging
      if (G4Hadronic_Random_File) {
         CLHEP::HepRandom::saveEngineStatus(G4Hadronic_Random_File);
      }
      // Call the interaction
      result = theInteraction->ApplyYourself( thePro, targetNucleus);
      ++reentryCount;
    }
    catch(G4HadronicException aR)
    {
      G4ExceptionDescription ed;
      aR.Report(ed);
      ed << "Call for " << theInteraction->GetModelName() << G4endl;
      ed << "Target element "<<anElement->GetName()<<"  Z= "
     << targetNucleus.GetZ_asInt()
     << "  A= " << targetNucleus.GetA_asInt() << G4endl;
      DumpState(aTrack,"ApplyYourself",ed);
      ed << " ApplyYourself failed" << G4endl;
      G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
          ed);
    }
 
    // Check the result for catastrophic energy non-conservation
    result = CheckResult(thePro,targetNucleus, result);
 
    if(reentryCount>100) {
      G4ExceptionDescription ed;
      ed << "Call for " << theInteraction->GetModelName() << G4endl;
      ed << "Target element "<<anElement->GetName()<<"  Z= "
     << targetNucleus.GetZ_asInt()
     << "  A= " << targetNucleus.GetA_asInt() << G4endl;
      DumpState(aTrack,"ApplyYourself",ed);
      ed << " ApplyYourself does not completed after 100 attempts" << G4endl;
      G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
          ed);
    }
  }
  while(!result);
 
  result->SetTrafoToLab(thePro.GetTrafoToLab());
 
  ClearNumberOfInteractionLengthLeft();
 
  FillResult(result, aTrack);
 
  if (epReportLevel != 0) {
    CheckEnergyMomentumConservation(aTrack, targetNucleus);
  }
  return theTotalResult;
}

PreparePhysicsTable()

void G4HadronicProcess::PreparePhysicsTable ( const G4ParticleDefinition &  p )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronElasticProcess, and G4HadronStoppingProcess.

Definition at line 158 of file G4HadronicProcess.cc.

{
  if(getenv("G4HadronicProcess_debug")) {
    G4HadronicProcess_debug_flag = true;
  }
  G4HadronicProcessStore::Instance()->RegisterParticle(this, &p);
}

Referenced by G4HadronElasticProcess::PreparePhysicsTable().

ProcessDescription()

void G4HadronicProcess::ProcessDescription ( std::ostream &  outFile ) const

virtual

Reimplemented in G4AlphaInelasticProcess, G4AntiAlphaInelasticProcess, G4AntiDeuteronInelasticProcess, G4AntiHe3InelasticProcess, G4AntiLambdaInelasticProcess, G4AntiNeutronInelasticProcess, G4AntiOmegaMinusInelasticProcess, G4AntiProtonInelasticProcess, G4AntiSigmaMinusInelasticProcess, G4AntiSigmaPlusInelasticProcess, G4AntiTritonInelasticProcess, G4AntiXiMinusInelasticProcess, G4AntiXiZeroInelasticProcess, G4DeuteronInelasticProcess, G4ElectronNuclearProcess, G4HadronCaptureProcess, G4HadronFissionProcess, G4IonInelasticProcess, G4KaonMinusInelasticProcess, G4KaonPlusInelasticProcess, G4KaonZeroLInelasticProcess, G4KaonZeroSInelasticProcess, G4LambdaInelasticProcess, G4MuonNuclearProcess, G4NeutronInelasticProcess, G4OmegaMinusInelasticProcess, G4PhotoNuclearProcess, G4PionMinusInelasticProcess, G4PionPlusInelasticProcess, G4PositronNuclearProcess, G4ProtonInelasticProcess, G4SigmaMinusInelasticProcess, G4SigmaPlusInelasticProcess, G4TritonInelasticProcess, G4XiMinusInelasticProcess, G4XiZeroInelasticProcess, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronStoppingProcess, and G4MuonMinusCapture.

Definition at line 350 of file G4HadronicProcess.cc.

{
  outFile << "The description for this process has not been written yet.\n";
}

RegisterMe()

void G4HadronicProcess::RegisterMe

(

G4HadronicInteraction *

a

)

Definition at line 142 of file G4HadronicProcess.cc.

{
  if(!a) { return; }
  try{GetManagerPointer()->RegisterMe( a );}
  catch(G4HadronicException & aE)
  {
    G4ExceptionDescription ed;
    aE.Report(ed);
    ed << "Unrecoverable error in " << GetProcessName()
       << " to register " << a->GetModelName() << G4endl;
    G4Exception("G4HadronicProcess::RegisterMe", "had001", FatalException,
        ed);
  }
  G4HadronicProcessStore::Instance()->RegisterInteraction(this, a);
}

Referenced by G4BertiniElectroNuclearBuilder::Build(), G4ElectroNuclearBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonLHEPBuilder::Build(), G4LHEPAntiBarionBuilder::Build(), G4MiscBuilder::Build(), G4MiscLHEPBuilder::Build(), G4MiscQGSCBuilder::Build(), G4FTFPAntiBarionBuilder::Build(), G4NeutronHPBuilder::Build(), G4NeutronLENDBuilder::Build(), G4LEPNeutronBuilder::Build(), G4BertiniKaonBuilder::Build(), G4FTFBinaryKaonBuilder::Build(), G4BertiniNeutronBuilder::Build(), G4BinaryNeutronBuilder::Build(), G4FTFBinaryNeutronBuilder::Build(), G4FTFCNeutronBuilder::Build(), G4FTFPNeutronBuilder::Build(), G4INCLXXNeutronBuilder::Build(), G4LHEPNeutronBuilder::Build(), G4PrecoNeutronBuilder::Build(), G4QGSBinaryNeutronBuilder::Build(), G4QGSC_CHIPSNeutronBuilder::Build(), G4QGSC_QGSCNeutronBuilder::Build(), G4QGSCEflowNeutronBuilder::Build(), G4QGSCNeutronBuilder::Build(), G4QGSPNeutronBuilder::Build(), G4BertiniPiKBuilder::Build(), G4BertiniPionBuilder::Build(), G4BinaryPiKBuilder::Build(), G4BinaryPionBuilder::Build(), G4FTFBinaryPiKBuilder::Build(), G4FTFBinaryPionBuilder::Build(), G4FTFCPiKBuilder::Build(), G4FTFPPiKBuilder::Build(), G4INCLXXPiKBuilder::Build(), G4LEPPiKBuilder::Build(), G4LEPPionBuilder::Build(), G4LHEPPiKBuilder::Build(), G4QGSBinaryPiKBuilder::Build(), G4QGSC_CHIPSPiKBuilder::Build(), G4QGSC_QGSCPiKBuilder::Build(), G4QGSCEflowPiKBuilder::Build(), G4QGSCPiKBuilder::Build(), G4QGSPPiKBuilder::Build(), G4QGSPPionBuilder::Build(), G4BertiniProtonBuilder::Build(), G4BinaryProtonBuilder::Build(), G4FTFBinaryProtonBuilder::Build(), G4FTFCProtonBuilder::Build(), G4FTFPProtonBuilder::Build(), G4INCLXXProtonBuilder::Build(), G4LEPProtonBuilder::Build(), G4LHEPProtonBuilder::Build(), G4PrecoProtonBuilder::Build(), G4QGSBinaryProtonBuilder::Build(), G4QGSC_CHIPSProtonBuilder::Build(), G4QGSC_QGSCProtonBuilder::Build(), G4QGSCEflowProtonBuilder::Build(), G4QGSCProtonBuilder::Build(), G4QGSPProtonBuilder::Build(), G4ChargeExchangePhysics::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronElasticPhysicsHP::ConstructProcess(), G4HadronElasticPhysicsLEND::ConstructProcess(), G4HadronElasticPhysicsLHEP::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronQElasticPhysics::ConstructProcess(), G4IonLHEPPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), HadronPhysicsFTFP_BERT_TRV::ConstructProcess(), G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini(), G4HadronicAbsorptionFritiof::G4HadronicAbsorptionFritiof(), and G4MuonMinusCapture::G4MuonMinusCapture().

SetEnergyMomentumCheckLevels()

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

inline

Definition at line 160 of file G4HadronicProcess.hh.

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

Referenced by G4HadronicProcessStore::SetProcessAbsLevel(), and G4HadronicProcessStore::SetProcessRelLevel().

SetEnergyRangeManager()

void G4HadronicProcess::SetEnergyRangeManager ( const G4EnergyRangeManager &  value )

inlineprotected

Definition at line 185 of file G4HadronicProcess.hh.

  { theEnergyRangeManager = value; }

SetEpReportLevel()

void G4HadronicProcess::SetEpReportLevel ( G4int  level )

inline

Definition at line 157 of file G4HadronicProcess.hh.

  { epReportLevel = level; }

Member Data Documentation

epReportLevel

G4int G4HadronicProcess::epReportLevel

protected

Definition at line 224 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), CheckEnergyMomentumConservation(), CheckResult(), PostStepDoIt(), and SetEpReportLevel().

thePro

G4HadProjectile G4HadronicProcess::thePro

protected

Definition at line 220 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), and PostStepDoIt().

theTotalResult

G4ParticleChange* G4HadronicProcess::theTotalResult

protected

Definition at line 222 of file G4HadronicProcess.hh.

Referenced by G4HadronStoppingProcess::AtRestDoIt(), CheckEnergyMomentumConservation(), FillResult(), G4HadronicProcess(), PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4WHadronElasticProcess::PostStepDoIt(), and ~G4HadronicProcess().

---

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

• G4HadronicProcess.hh
• G4HadronicProcess.cc