#include <G4HadronicProcess.hh>

Inheritance diagram for G4HadronicProcess:

Collaboration 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=nullptr)

G4double	GetMicroscopicCrossSection (const G4DynamicParticle part, const G4Element elm, const G4Material *mat=nullptr)

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)

std::vector < G4HadronicInteraction * > &	GetHadronicInteractionList ()

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	SetIntegral (G4bool val)

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

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

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
G4HadronicInteraction *	ChooseHadronicInteraction (const G4HadProjectile &aHadProjectile, G4Nucleus &aTargetNucleus, G4Material aMaterial, G4Element anElement)

G4Nucleus *	GetTargetNucleusPointer ()

void	DumpState (const G4Track &, const G4String &, G4ExceptionDescription &)

G4HadronicInteraction *	GetHadronicInteraction () const

G4double	GetLastCrossSection ()

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

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

void	CheckEnergyMomentumConservation (const G4Track &, const G4Nucleus &)

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

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::G4HadronicProcess	(	const G4String &	processName = `"Hadronic"`,
		G4ProcessType	procType = `fHadronic`
	)

Definition at line 86 of file G4HadronicProcess.cc.

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

Here is the call graph for this function:

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

Definition at line 110 of file G4HadronicProcess.cc.

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

Here is the call graph for this function:

G4HadronicProcess::~G4HadronicProcess ( )

virtual

Definition at line 133 of file G4HadronicProcess.cc.

 {
   theProcessStore->DeRegister(this);
   delete theTotalResult;
   delete theCrossSectionDataStore;
 }

Here is the call graph for this function:

Member Function Documentation

void G4HadronicProcess::AddDataSet ( G4VCrossSectionDataSet * aDataSet )

inline

Definition at line 111 of file G4HadronicProcess.hh.

112 { theCrossSectionDataStore->AddDataSet(aDataSet);}

G4CrossSectionDataStore::AddDataSet

void AddDataSet(G4VCrossSectionDataSet *)

Definition: G4CrossSectionDataStore.hh:160

Here is the call graph for this function:

void G4HadronicProcess::BiasCrossSectionByFactor ( G4double aScale )

Definition at line 562 of file G4HadronicProcess.cc.

 {
   xBiasOn = true;
   aScaleFactor = aScale;
   G4String it = GetProcessName();
   if ((it != "photonNuclear") &&
       (it != "electronNuclear") &&
       (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.;
   }
 }

Here is the call graph for this function:

void G4HadronicProcess::BuildPhysicsTable ( const G4ParticleDefinition & p )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, G4MuonMinusAtomicCapture, and G4ChargeExchangeProcess.

Definition at line 209 of file G4HadronicProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 667 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 << " 3mom: " << (diff.vect())*1./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;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 584 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 
       // and 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++) {
       G4DynamicParticle *pdyn=result->GetSecondary(i)->GetParticle();
       finalE += pdyn->GetTotalEnergy();
       G4double mass_pdg=pdyn->GetDefinition()->GetPDGMass();
       G4double mass_dyn=pdyn->GetMass();
       if ( std::abs(mass_pdg - mass_dyn) > 0.1*mass_pdg + 1.*MeV){
           result->Clear();
           result = 0;
           G4ExceptionDescription desc;
           desc << "Warning: Secondary with off-shell dynamic mass detected:  " << G4endl
            << " " << pdyn->GetDefinition()->GetParticleName()
            << ", PDG mass: " << mass_pdg << ", dynamic mass: "<< mass_dyn << G4endl
            << (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;
           G4Exception("G4HadronicProcess:CheckResult()", "had012",
               epReportLevel<0 ? EventMustBeAborted : JustWarning,desc);
           // must return here.....
           return result;
       }
     }
     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->Clear();
       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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4HadronicInteraction* G4HadronicProcess::ChooseHadronicInteraction	(	const G4HadProjectile &	aHadProjectile,
		G4Nucleus &	aTargetNucleus,
		G4Material *	aMaterial,
		G4Element *	anElement
	)

inlineprotected

Definition at line 136 of file G4HadronicProcess.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4HadronicProcess::DumpPhysicsTable ( const G4ParticleDefinition & p )

inline

Definition at line 107 of file G4HadronicProcess.hh.

108 { theCrossSectionDataStore->DumpPhysicsTable(p); }

G4CrossSectionDataStore::DumpPhysicsTable

void DumpPhysicsTable(const G4ParticleDefinition &)

Definition: G4CrossSectionDataStore.cc:546

Here is the call graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 461 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)
          { theTotalResult->ProposeTrackStatus(fStopButAlive); }
     else { theTotalResult->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 );
   }
   //G4cout << "FillResult: Efinal= " << efinal << " status= " 
   //     << theTotalResult->GetTrackStatus() 
   //     << "  fKill= " << fStopAndKill << G4endl;
 
   // 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());
       track->SetCreatorModelIndex(aR->GetSecondary(i)->GetCreatorModelType());
       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();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4CrossSectionDataStore* G4HadronicProcess::GetCrossSectionDataStore ( )

inline

Definition at line 170 of file G4HadronicProcess.hh.

171 {return theCrossSectionDataStore;}

Here is the caller graph for this function:

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

Definition at line 170 of file G4HadronicProcess.cc.

 {
   G4Material* aMaterial = const_cast<G4Material*>(mat);
   if(!aMaterial) 
   {
     // Because NeutronHP needs a material pointer (for instance to get the
     // temperature), we ask the Nist manager to find a simple material
     // from the (integer) Z of the element. 
     aMaterial = 
       G4NistManager::Instance()->FindSimpleMaterial(elm->GetZasInt());
     if(!aMaterial) {
       ++nMatWarn;
       static const G4int nmax = 5;
       if(nMatWarn < nmax) {
     G4ExceptionDescription ed;
     ed << "Cannot compute Element x-section for " << GetProcessName()
        << " because no material defined \n"
        << " Please, specify material pointer or define simple material"
        << " for Z= " << elm->GetZasInt();
     G4Exception("G4HadronicProcess::GetElementCrossSection", "had066", JustWarning,
             ed);
       }
     }
   }
   G4double x = 
     std::max(theCrossSectionDataStore->GetCrossSection(part, elm, aMaterial),0.0);
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Definition at line 166 of file G4HadronicProcess.hh.

167 { return epCheckLevels; }

Here is the caller graph for this function:

G4HadronicInteraction* G4HadronicProcess::GetHadronicInteraction ( ) const

inlineprotected

Definition at line 181 of file G4HadronicProcess.hh.

182 { return theInteraction; }

Here is the caller graph for this function:

std::vector<G4HadronicInteraction*>& G4HadronicProcess::GetHadronicInteractionList ( )

inline

Definition at line 115 of file G4HadronicProcess.hh.

116 { return theEnergyRangeManager.GetHadronicInteractionList(); }

G4EnergyRangeManager::GetHadronicInteractionList

std::vector< G4HadronicInteraction * > & GetHadronicInteractionList()

Definition: G4EnergyRangeManager.cc:269

Here is the call graph for this function:

G4double G4HadronicProcess::GetLastCrossSection ( )

inlineprotected

Definition at line 185 of file G4HadronicProcess.hh.

186 { return theLastCrossSection; }

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

virtual

Implements G4VDiscreteProcess.

Definition at line 228 of file G4HadronicProcess.cc.

 {
   //G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
   //     << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
   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 = (theLastCrossSection > 0.0) ? 1.0/theLastCrossSection : DBL_MAX;
   //G4cout << "         xsection= " << res << G4endl;
   return res;
 }

Here is the call graph for this function:

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

inline

Definition at line 91 of file G4HadronicProcess.hh.

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

G4HadronicProcess::GetElementCrossSection

G4double GetElementCrossSection(const G4DynamicParticle *part, const G4Element *elm, const G4Material *mat=nullptr)

Definition: G4HadronicProcess.cc:170

Here is the call graph for this function:

const G4Isotope* G4HadronicProcess::GetTargetIsotope ( )

inline

Definition at line 127 of file G4HadronicProcess.hh.

128 { return targetNucleus.GetIsotope(); }

G4Nucleus::GetIsotope

const G4Isotope * GetIsotope()

Definition: G4Nucleus.hh:119

Here is the call graph for this function:

const G4Nucleus* G4HadronicProcess::GetTargetNucleus ( ) const

inline

Definition at line 123 of file G4HadronicProcess.hh.

124 { return &targetNucleus; }

G4Nucleus* G4HadronicProcess::GetTargetNucleusPointer ( )

inlineprotected

Definition at line 145 of file G4HadronicProcess.hh.

146 { return &targetNucleus; }

Here is the caller graph for this function:

void G4HadronicProcess::MultiplyCrossSectionBy ( G4double factor )

inline

Definition at line 173 of file G4HadronicProcess.hh.

174 { aScaleFactor = factor; }

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

virtual

Reimplemented from G4VDiscreteProcess.

Reimplemented in G4HadronElasticProcess.

Definition at line 253 of file G4HadronicProcess.cc.

 {
   //G4cout << "PostStepDoIt " << aTrack.GetDefinition()->GetParticleName()
   //     << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
   // 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();
 
   // check only for charged particles
   if(aParticle->GetDefinition()->GetPDGCharge() != 0.0) {
     G4double xs = 0.0;
     try
     {
       xs = aScaleFactor*theCrossSectionDataStore->GetCrossSection(aParticle,aMaterial);
     }
     catch(G4HadronicException aR)
     {
       G4ExceptionDescription ed;
       aR.Report(ed);
       DumpState(aTrack,"PostStepDoIt",ed);
       ed << " Cross section is not available" << G4endl;
       G4Exception("G4HadronicProcess::PostStepDoIt", "had002", FatalException,ed);
     }
     if(xs <= 0.0 || (useIntegralXS && xs < theLastCrossSection*G4UniformRand())) {
       // No interaction
       return theTotalResult;
     }    
   }
 
   G4Element* anElement = nullptr;
   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);
   }
 
   // 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;
   }
 
   // Initialize the hadronic projectile from the track
   thePro.Initialise(aTrack);
 
   try
   {
     theInteraction =
       ChooseHadronicInteraction( thePro, targetNucleus, 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);
   }
 
   G4HadFinalState* result = nullptr;
   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
     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);  /* Loop checking, 30-Oct-2015, G.Folger */
 
   // Check whether kaon0 or anti_kaon0 are present between the secondaries: 
   // if this is the case, transform them into either kaon0S or kaon0L,
   // with equal, 50% probability, keeping their dynamical masses (and
   // the other kinematical properties). 
   // When this happens - very rarely - a "JustWarning" exception is thrown.
   G4int nSec = result->GetNumberOfSecondaries();
   if ( nSec > 0 ) {
     for ( G4int i = 0; i < nSec; ++i ) {
       G4DynamicParticle* dynamicParticle = result->GetSecondary(i)->GetParticle();
       const G4ParticleDefinition* particleDefinition = dynamicParticle->GetParticleDefinition();
       if ( particleDefinition == G4KaonZero::Definition() || 
            particleDefinition == G4AntiKaonZero::Definition() ) {
         G4ParticleDefinition* newParticleDefinition = G4KaonZeroShort::Definition();
         if ( G4UniformRand() > 0.5 ) newParticleDefinition = G4KaonZeroLong::Definition();
         G4double dynamicMass = dynamicParticle->GetMass();
         dynamicParticle->SetDefinition( newParticleDefinition );
         dynamicParticle->SetMass( dynamicMass );               
         G4ExceptionDescription ed;
         ed << " Hadronic model " << theInteraction->GetModelName() << G4endl;
         ed << " created " << particleDefinition->GetParticleName() << G4endl;
         ed << " -> forced to be " << newParticleDefinition->GetParticleName() << G4endl;
         G4Exception( "G4HadronicProcess::PostStepDoIt", "had007", JustWarning, ed );
         //if ( std::abs( dynamicMass - particleDefinition->GetPDGMass() ) > 0.1*CLHEP::eV ) {
         //  G4cout << "\t dynamicMass=" << dynamicMass << " != PDGMass=" 
         //         << particleDefinition->GetPDGMass() << G4endl;
         //}
       }
     }
   }
 
   result->SetTrafoToLab(thePro.GetTrafoToLab());
 
   ClearNumberOfInteractionLengthLeft();
 
   FillResult(result, aTrack);
 
   if (epReportLevel != 0) {
     CheckEnergyMomentumConservation(aTrack, targetNucleus);
   }
   //G4cout << "PostStepDoIt done " << G4endl;
   return theTotalResult;
 }

Here is the call graph for this function:

void G4HadronicProcess::PreparePhysicsTable ( const G4ParticleDefinition & p )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4HadronStoppingProcess, G4MuonMinusAtomicCapture, and G4HadronElasticProcess.

Definition at line 201 of file G4HadronicProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Definition at line 435 of file G4HadronicProcess.cc.

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

Here is the caller graph for this function:

void G4HadronicProcess::RegisterMe ( G4HadronicInteraction * a )

Definition at line 153 of file G4HadronicProcess.cc.

 {
   if(!a) { return; }
   try{ theEnergyRangeManager.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);
 }

Here is the call graph for this function:

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

inline

Definition at line 160 of file G4HadronicProcess.hh.

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

Here is the caller graph for this function:

void G4HadronicProcess::SetEpReportLevel ( G4int level )

inline

Definition at line 157 of file G4HadronicProcess.hh.

158 { epReportLevel = level; }

G4HadronicProcess::epReportLevel

G4int epReportLevel

Definition: G4HadronicProcess.hh:216

void G4HadronicProcess::SetIntegral ( G4bool val )

inline

Definition at line 153 of file G4HadronicProcess.hh.

154 { useIntegralXS = val; }

Member Data Documentation

G4int G4HadronicProcess::epReportLevel

protected

Definition at line 216 of file G4HadronicProcess.hh.

G4HadProjectile G4HadronicProcess::thePro

protected

Definition at line 212 of file G4HadronicProcess.hh.

G4ParticleChange* G4HadronicProcess::theTotalResult

protected

Definition at line 214 of file G4HadronicProcess.hh.

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

geant4.10.03.p01/source/processes/hadronic/management/include/G4HadronicProcess.hh
geant4.10.03.p01/source/processes/hadronic/management/src/G4HadronicProcess.cc

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation