G4HadronicProcess Class Reference

#include <G4HadronicProcess.hh>

Inheritance diagram for G4HadronicProcess:

G4VDiscreteProcess G4VProcess G4ChargeExchangeProcess G4HadronCaptureProcess G4HadronElasticProcess G4HadronFissionProcess G4HadronInelasticProcess G4HadronStoppingProcess G4MuonNuclearProcess G4WHadronElasticProcess

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 G4VParticleChangePostStepDoIt (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)
G4EnergyRangeManagerGetManagerPointer ()
G4double GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *)
const G4NucleusGetTargetNucleus () const
const G4IsotopeGetTargetIsotope ()
virtual void ProcessDescription (std::ostream &outFile) const
void BiasCrossSectionByFactor (G4double aScale)
void SetEpReportLevel (G4int level)
void SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
std::pair< G4double, G4doubleGetEnergyMomentumCheckLevels () const
G4CrossSectionDataStoreGetCrossSectionDataStore ()
void MultiplyCrossSectionBy (G4double factor)

Protected Member Functions

G4HadronicInteractionChooseHadronicInteraction (G4double kineticEnergy, G4Material *aMaterial, G4Element *anElement)
G4NucleusGetTargetNucleusPointer ()
void DumpState (const G4Track &, const G4String &, G4ExceptionDescription &)
const G4EnergyRangeManagerGetEnergyRangeManager () const
void SetEnergyRangeManager (const G4EnergyRangeManager &value)
G4HadronicInteractionGetHadronicInteraction () const
G4double GetLastCrossSection ()
void FillResult (G4HadFinalState *aR, const G4Track &aT)
G4HadFinalStateCheckResult (const G4HadProjectile &thePro, const G4Nucleus &targetNucleus, G4HadFinalState *result) const
void CheckEnergyMomentumConservation (const G4Track &, const G4Nucleus &)

Protected Attributes

G4HadProjectile thePro
G4ParticleChangetheTotalResult
G4int epReportLevel

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 83 of file G4HadronicProcess.cc.

References fHadronInelastic, G4HadronicProcessStore::Instance(), G4HadronicProcessStore::Register(), G4VProcess::SetProcessSubType(), G4VParticleChange::SetSecondaryWeightByProcess(), and theTotalResult.

00085  : G4VDiscreteProcess(processName, procType)
00086 {
00087   SetProcessSubType(fHadronInelastic);  // Default unless subclass changes
00088   
00089   theTotalResult = new G4ParticleChange();
00090   theTotalResult->SetSecondaryWeightByProcess(true);
00091   theInteraction = 0;
00092   theCrossSectionDataStore = new G4CrossSectionDataStore();
00093   G4HadronicProcessStore::Instance()->Register(this);
00094   aScaleFactor = 1;
00095   xBiasOn = false;
00096   G4HadronicProcess_debug_flag = false;
00097 
00098   GetEnergyMomentumCheckEnvvars();
00099 }

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

Definition at line 103 of file G4HadronicProcess.cc.

References G4HadronicProcessStore::Instance(), G4HadronicProcessStore::Register(), G4VProcess::SetProcessSubType(), G4VParticleChange::SetSecondaryWeightByProcess(), and theTotalResult.

00105  : G4VDiscreteProcess(processName, fHadronic)
00106 {
00107   SetProcessSubType(aHadSubType);
00108 
00109   theTotalResult = new G4ParticleChange();
00110   theTotalResult->SetSecondaryWeightByProcess(true);
00111   theInteraction = 0;
00112   theCrossSectionDataStore = new G4CrossSectionDataStore();
00113   G4HadronicProcessStore::Instance()->Register(this);
00114   aScaleFactor = 1;
00115   xBiasOn = false;
00116   G4HadronicProcess_debug_flag = false;
00117 
00118   GetEnergyMomentumCheckEnvvars();
00119 }

G4HadronicProcess::~G4HadronicProcess (  )  [virtual]

Definition at line 122 of file G4HadronicProcess.cc.

References G4HadronicProcessStore::DeRegister(), G4HadronicProcessStore::Instance(), and theTotalResult.

00123 {
00124   G4HadronicProcessStore::Instance()->DeRegister(this);
00125   delete theTotalResult;
00126   delete theCrossSectionDataStore;
00127 }


Member Function Documentation

void G4HadronicProcess::AddDataSet ( G4VCrossSectionDataSet aDataSet  )  [inline]

Definition at line 117 of file G4HadronicProcess.hh.

References G4CrossSectionDataStore::AddDataSet().

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

00118   { theCrossSectionDataStore->AddDataSet(aDataSet);}

void G4HadronicProcess::BiasCrossSectionByFactor ( G4double  aScale  ) 

Definition at line 605 of file G4HadronicProcess.cc.

References FatalException, G4Exception(), G4VProcess::GetProcessName(), and JustWarning.

00606 {
00607   xBiasOn = true;
00608   aScaleFactor = aScale;
00609   G4String it = GetProcessName();
00610   if( (it != "PhotonInelastic") &&
00611       (it != "ElectroNuclear") &&
00612       (it != "PositronNuclear") )
00613     {
00614       G4ExceptionDescription ed;
00615       G4Exception("G4HadronicProcess::BiasCrossSectionByFactor", "had009", FatalException, ed,
00616                   "Cross-section biasing available only for gamma and electro nuclear reactions.");
00617     }
00618   if(aScale<100)
00619     {
00620       G4ExceptionDescription ed;
00621       G4Exception("G4HadronicProcess::BiasCrossSectionByFactor", "had010", JustWarning,ed,
00622                   "Cross-section bias readjusted to be above safe limit. New value is 100");
00623       aScaleFactor = 100.;
00624     }
00625 }

void G4HadronicProcess::BuildPhysicsTable ( const G4ParticleDefinition  )  [virtual]

Reimplemented from G4VProcess.

Reimplemented in G4ChargeExchangeProcess, and G4HadronStoppingProcess.

Definition at line 166 of file G4HadronicProcess.cc.

References G4CrossSectionDataStore::BuildPhysicsTable(), FatalException, G4endl, G4Exception(), G4HadronicProcessStore::Instance(), G4HadronicProcessStore::PrintInfo(), and G4HadronicException::Report().

Referenced by G4ChargeExchangeProcess::BuildPhysicsTable().

00167 {
00168   try
00169   {
00170     theCrossSectionDataStore->BuildPhysicsTable(p);
00171   }
00172   catch(G4HadronicException aR)
00173   {
00174     G4ExceptionDescription ed;
00175     aR.Report(ed);
00176     ed << " hadronic initialisation fails" << G4endl;
00177     G4Exception("G4HadronicProcess::BuildPhysicsTable", "had000", 
00178                 FatalException,ed);
00179   }
00180   G4HadronicProcessStore::Instance()->PrintInfo(&p);
00181 }

void G4HadronicProcess::CheckEnergyMomentumConservation ( const G4Track ,
const G4Nucleus  
) [protected]

Definition at line 677 of file G4HadronicProcess.cc.

References DBL_MAX, epReportLevel, G4String::first(), fStopAndKill, G4cerr, G4cout, G4endl, G4lrint(), G4DynamicParticle::Get4Momentum(), G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetBaryonNumber(), G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4ParticleChange::GetEnergy(), GetHadronicInteraction(), G4Track::GetKineticEnergy(), G4HadronicInteraction::GetModelName(), G4Track::GetMomentum(), G4ParticleChange::GetMomentumDirection(), G4NucleiProperties::GetNuclearMass(), G4VParticleChange::GetNumberOfSecondaries(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), G4VProcess::GetProcessName(), G4VParticleChange::GetSecondary(), G4VParticleChange::GetTrackStatus(), G4Nucleus::GetZ_asInt(), and theTotalResult.

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

00679 {
00680   G4int target_A=aNucleus.GetA_asInt();
00681   G4int target_Z=aNucleus.GetZ_asInt();
00682   G4double targetMass = G4NucleiProperties::GetNuclearMass(target_A,target_Z);
00683   G4LorentzVector target4mom(0, 0, 0, targetMass);
00684 
00685   G4LorentzVector projectile4mom = aTrack.GetDynamicParticle()->Get4Momentum();
00686   G4int track_A = aTrack.GetDefinition()->GetBaryonNumber();
00687   G4int track_Z = G4lrint(aTrack.GetDefinition()->GetPDGCharge());
00688 
00689   G4int initial_A = target_A + track_A;
00690   G4int initial_Z = target_Z + track_Z;
00691 
00692   G4LorentzVector initial4mom = projectile4mom + target4mom;
00693 
00694   // Compute final-state momentum for scattering and "do nothing" results
00695   G4LorentzVector final4mom;
00696   G4int final_A(0), final_Z(0);
00697 
00698   G4int nSec = theTotalResult->GetNumberOfSecondaries();
00699   if (theTotalResult->GetTrackStatus() != fStopAndKill) {  // If it is Alive
00700      // Either interaction didn't complete, returned "do nothing" state
00701      //  or    the primary survived the interaction (e.g. electro-nucleus )
00702      G4Track temp(aTrack);
00703 
00704      // Use the final energy / momentum
00705      temp.SetMomentumDirection(*theTotalResult->GetMomentumDirection());
00706      temp.SetKineticEnergy(theTotalResult->GetEnergy());
00707 
00708      if( nSec == 0 ){
00709         // Interaction didn't complete, returned "do nothing" state
00710         //   - or suppressed recoil  (e.g. Neutron elastic )
00711         final4mom = temp.GetDynamicParticle()->Get4Momentum() + target4mom;
00712         final_A = initial_A;
00713         final_Z = initial_Z;
00714      }else{
00715         // The primary remains in final state (e.g. electro-nucleus )
00716         final4mom = temp.GetDynamicParticle()->Get4Momentum();
00717         final_A = track_A;
00718         final_Z = track_Z;
00719         // Expect that the target nucleus will have interacted,
00720         //  and its products, including recoil, will be included in secondaries.
00721      }
00722   }
00723   if( nSec > 0 ) {
00724     G4Track* sec;
00725 
00726     for (G4int i = 0; i < nSec; i++) {
00727       sec = theTotalResult->GetSecondary(i);
00728       final4mom += sec->GetDynamicParticle()->Get4Momentum();
00729       final_A += sec->GetDefinition()->GetBaryonNumber();
00730       final_Z += G4lrint(sec->GetDefinition()->GetPDGCharge());
00731     }
00732   }
00733 
00734   // Get level-checking information (used to cut-off relative checks)
00735   G4String processName = GetProcessName();
00736   G4HadronicInteraction* theModel = GetHadronicInteraction();
00737   G4String modelName("none");
00738   if (theModel) modelName = theModel->GetModelName();
00739   std::pair<G4double, G4double> checkLevels = epCheckLevels;
00740   if (!levelsSetByProcess) {
00741     if (theModel) checkLevels = theModel->GetEnergyMomentumCheckLevels();
00742     checkLevels.first= std::min(checkLevels.first,  epCheckLevels.first);
00743     checkLevels.second=std::min(checkLevels.second, epCheckLevels.second);
00744   }
00745 
00746   // Compute absolute total-energy difference, and relative kinetic-energy
00747   G4bool checkRelative = (aTrack.GetKineticEnergy() > checkLevels.second);
00748 
00749   G4LorentzVector diff = initial4mom - final4mom;
00750   G4double absolute = diff.e();
00751   G4double relative = checkRelative ? absolute/aTrack.GetKineticEnergy() : 0.;
00752 
00753   G4double absolute_mom = diff.vect().mag();
00754   G4double relative_mom = checkRelative ? absolute_mom/aTrack.GetMomentum().mag() : 0.;
00755 
00756   // Evaluate relative and absolute conservation
00757   G4bool relPass = true;
00758   G4String relResult = "pass";
00759   if (  std::abs(relative) > checkLevels.first
00760          || std::abs(relative_mom) > checkLevels.first) {
00761     relPass = false;
00762     relResult = checkRelative ? "fail" : "N/A";
00763   }
00764 
00765   G4bool absPass = true;
00766   G4String absResult = "pass";
00767   if (   std::abs(absolute) > checkLevels.second
00768       || std::abs(absolute_mom) > checkLevels.second ) {
00769     absPass = false ;
00770     absResult = "fail";
00771   }
00772 
00773   G4bool chargePass = true;
00774   G4String chargeResult = "pass";
00775   if (   (initial_A-final_A)!=0
00776       || (initial_Z-final_Z)!=0 ) {
00777     chargePass = checkLevels.second < DBL_MAX ? false : true;
00778     chargeResult = "fail";
00779    }
00780 
00781   G4bool conservationPass = (relPass || absPass) && chargePass;
00782 
00783   std::stringstream Myout;
00784   G4bool Myout_notempty(false);
00785   // Options for level of reporting detail:
00786   //  0. off
00787   //  1. report only when E/p not conserved
00788   //  2. report regardless of E/p conservation
00789   //  3. report only when E/p not conserved, with model names, process names, and limits
00790   //  4. report regardless of E/p conservation, with model names, process names, and limits
00791   //  negative -1.., as above, but send output to stderr
00792 
00793   if(   std::abs(epReportLevel) == 4
00794         ||      ( std::abs(epReportLevel) == 3 && ! conservationPass ) ){
00795       Myout << " Process: " << processName << " , Model: " <<  modelName << G4endl;
00796       Myout << " Primary: " << aTrack.GetParticleDefinition()->GetParticleName()
00797             << " (" << aTrack.GetParticleDefinition()->GetPDGEncoding() << "),"
00798             << " E= " <<  aTrack.GetDynamicParticle()->Get4Momentum().e()
00799             << ", target nucleus (" << aNucleus.GetZ_asInt() << ","
00800             << aNucleus.GetA_asInt() << ")" << G4endl;
00801       Myout_notempty=true;
00802   }
00803   if (  std::abs(epReportLevel) == 4
00804          || std::abs(epReportLevel) == 2
00805          || ! conservationPass ){
00806 
00807       Myout << "   "<< relResult  <<" relative, limit " << checkLevels.first << ", values E/T(0) = "
00808              << relative << " p/p(0)= " << relative_mom  << G4endl;
00809       Myout << "   "<< absResult << " absolute, limit (MeV) " << checkLevels.second/MeV << ", values E / p (MeV) = "
00810              << absolute/MeV << " / " << absolute_mom/MeV << G4endl;
00811       Myout << "   "<< chargeResult << " charge/baryon number balance " << (initial_Z-final_Z) << " / " << (initial_A-final_A) << " "<<  G4endl;
00812       Myout_notempty=true;
00813 
00814   }
00815   Myout.flush();
00816   if ( Myout_notempty ) {
00817      if (epReportLevel > 0)      G4cout << Myout.str()<< G4endl;
00818      else if (epReportLevel < 0) G4cerr << Myout.str()<< G4endl;
00819   }
00820 }

G4HadFinalState * G4HadronicProcess::CheckResult ( const G4HadProjectile thePro,
const G4Nucleus targetNucleus,
G4HadFinalState result 
) const [protected]

Definition at line 627 of file G4HadronicProcess.cc.

References epReportLevel, EventMustBeAborted, G4endl, G4Exception(), G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4HadProjectile::GetDefinition(), G4HadFinalState::GetEnergyChange(), G4HadronicInteraction::GetFatalEnergyCheckLevels(), GetHadronicInteraction(), G4HadProjectile::GetKineticEnergy(), G4HadFinalState::GetLocalEnergyDeposit(), G4HadronicInteraction::GetModelName(), G4NucleiProperties::GetNuclearMass(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetPDGMass(), G4VProcess::GetProcessName(), G4HadFinalState::GetSecondary(), G4HadFinalState::GetStatusChange(), G4HadProjectile::GetTotalEnergy(), G4DynamicParticle::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), JustWarning, and stopAndKill.

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

00628 {
00629    // check for catastrophic energy non-conservation, to re-sample the interaction
00630 
00631    G4HadronicInteraction * theModel = GetHadronicInteraction();
00632    G4double nuclearMass(0);
00633    if (theModel){
00634 
00635       // Compute final-state total energy
00636       G4double finalE(0.);
00637       G4int nSec = result->GetNumberOfSecondaries();
00638 
00639       nuclearMass = G4NucleiProperties::GetNuclearMass(aNucleus.GetA_asInt(),
00640                                                        aNucleus.GetZ_asInt());
00641       if (result->GetStatusChange() != stopAndKill) {
00642         // Interaction didn't complete, returned "do nothing" state          => reset nucleus
00643         //  or  the primary survived the interaction (e.g. electro-nuclear ) => keep  nucleus
00644          finalE=result->GetLocalEnergyDeposit() +
00645                 aPro.GetDefinition()->GetPDGMass() + result->GetEnergyChange();
00646          if( nSec == 0 ){
00647             // Since there are no secondaries, there is no recoil nucleus.
00648             // To check energy balance we must neglect the initial nucleus too.
00649             nuclearMass=0.0;
00650          }
00651       }
00652       for (G4int i = 0; i < nSec; i++) {
00653          finalE += result->GetSecondary(i)->GetParticle()->GetTotalEnergy();
00654       }
00655       G4double deltaE= nuclearMass +  aPro.GetTotalEnergy() -  finalE;
00656 
00657       std::pair<G4double, G4double> checkLevels = theModel->GetFatalEnergyCheckLevels();        // (relative, absolute)
00658       if (std::abs(deltaE) > checkLevels.second && std::abs(deltaE) > checkLevels.first*aPro.GetKineticEnergy()){
00659          // do not delete result, this is a pointer to a data member;
00660          result=0;
00661          G4ExceptionDescription desc;
00662          desc << "Warning: Bad energy non-conservation detected, will "
00663               << (epReportLevel<0 ? "abort the event" : "re-sample the interaction") << G4endl
00664               << " Process / Model: " <<  GetProcessName()<< " / " << theModel->GetModelName() << G4endl
00665               << " Primary: " << aPro.GetDefinition()->GetParticleName()
00666               << " (" << aPro.GetDefinition()->GetPDGEncoding() << "),"
00667               << " E= " <<  aPro.Get4Momentum().e()
00668               << ", target nucleus (" << aNucleus.GetZ_asInt() << ","<< aNucleus.GetA_asInt() << ")" << G4endl
00669               << " E(initial - final) = " << deltaE << " MeV." << G4endl;
00670          G4Exception("G4HadronicProcess:CheckResult()", "had012", epReportLevel<0 ? EventMustBeAborted : JustWarning,desc);
00671       }
00672    }
00673    return result;
00674 }

G4HadronicInteraction* G4HadronicProcess::ChooseHadronicInteraction ( G4double  kineticEnergy,
G4Material aMaterial,
G4Element anElement 
) [inline, protected]

Definition at line 142 of file G4HadronicProcess.hh.

References G4EnergyRangeManager::GetHadronicInteraction().

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

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

void G4HadronicProcess::DumpPhysicsTable ( const G4ParticleDefinition p  )  [inline]

Reimplemented in G4ChargeExchangeProcess.

Definition at line 113 of file G4HadronicProcess.hh.

References G4CrossSectionDataStore::DumpPhysicsTable().

00114   { theCrossSectionDataStore->DumpPhysicsTable(p); }

void G4HadronicProcess::DumpState ( const G4Track ,
const G4String ,
G4ExceptionDescription  
) [protected]

Definition at line 823 of file G4HadronicProcess.cc.

References G4endl, G4Track::GetKineticEnergy(), G4Track::GetMaterial(), G4Track::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4Material::GetName(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4Track::GetPosition(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), and G4Track::GetVolume().

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

00826 {
00827   ed << "Unrecoverable error in the method " << method << " of "
00828      << GetProcessName() << G4endl;
00829   ed << "TrackID= "<< aTrack.GetTrackID() << "  ParentID= "
00830      << aTrack.GetParentID()
00831      << "  " << aTrack.GetParticleDefinition()->GetParticleName()
00832      << G4endl;
00833   ed << "Ekin(GeV)= " << aTrack.GetKineticEnergy()/CLHEP::GeV
00834      << ";  direction= " << aTrack.GetMomentumDirection() << G4endl;
00835   ed << "Position(mm)= " << aTrack.GetPosition()/CLHEP::mm << ";";
00836 
00837   if (aTrack.GetMaterial()) {
00838     ed << "  material " << aTrack.GetMaterial()->GetName();
00839   }
00840   ed << G4endl;
00841 
00842   if (aTrack.GetVolume()) {
00843     ed << "PhysicalVolume  <" << aTrack.GetVolume()->GetName()
00844        << ">" << G4endl;
00845   }
00846 }

void G4HadronicProcess::FillResult ( G4HadFinalState aR,
const G4Track aT 
) [protected]

Definition at line 376 of file G4HadronicProcess.cc.

References G4ParticleChange::AddSecondary(), G4VProcess::aParticleChange, G4HadFinalState::Clear(), DumpState(), fAlive, fStopAndKill, fStopButAlive, G4endl, G4Exception(), G4UniformRand, G4DynamicParticle::Get4Momentum(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetDefinition(), G4HadFinalState::GetEnergyChange(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4HadFinalState::GetLocalEnergyDeposit(), G4HadFinalState::GetMomentumChange(), G4HadFinalState::GetNumberOfSecondaries(), G4HadSecondary::GetParticle(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4Track::GetPosition(), G4ParticleDefinition::GetProcessManager(), G4HadFinalState::GetSecondary(), G4HadFinalState::GetStatusChange(), G4HadSecondary::GetTime(), G4Track::GetTouchableHandle(), G4HadFinalState::GetTrafoToLab(), G4HadSecondary::GetWeight(), G4Track::GetWeight(), JustWarning, G4ParticleChange::ProposeEnergy(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), G4DynamicParticle::Set4Momentum(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), G4ProcessVector::size(), stopAndKill, and theTotalResult.

Referenced by PostStepDoIt().

00377 {
00378   theTotalResult->ProposeLocalEnergyDeposit(aR->GetLocalEnergyDeposit());
00379 
00380   G4double rotation = CLHEP::twopi*G4UniformRand();
00381   G4ThreeVector it(0., 0., 1.);
00382 
00383   G4double efinal = aR->GetEnergyChange();
00384   if(efinal < 0.0) { efinal = 0.0; }
00385 
00386   // check status of primary
00387   if(aR->GetStatusChange() == stopAndKill) {
00388     theTotalResult->ProposeTrackStatus(fStopAndKill);
00389     theTotalResult->ProposeEnergy( 0.0 );
00390 
00391     // check its final energy
00392   } else if(0.0 == efinal) {
00393     theTotalResult->ProposeEnergy( 0.0 );
00394     if(aT.GetParticleDefinition()->GetProcessManager()
00395        ->GetAtRestProcessVector()->size() > 0)
00396          { aParticleChange.ProposeTrackStatus(fStopButAlive); }
00397     else { aParticleChange.ProposeTrackStatus(fStopAndKill); }
00398 
00399     // primary is not killed apply rotation and Lorentz transformation
00400   } else  {
00401     theTotalResult->ProposeTrackStatus(fAlive);
00402     G4double mass = aT.GetParticleDefinition()->GetPDGMass();
00403     G4double newE = efinal + mass;
00404     G4double newP = std::sqrt(efinal*(efinal + 2*mass));
00405     G4ThreeVector newPV = newP*aR->GetMomentumChange();
00406     G4LorentzVector newP4(newE, newPV);
00407     newP4.rotate(rotation, it);
00408     newP4 *= aR->GetTrafoToLab();
00409     theTotalResult->ProposeMomentumDirection(newP4.vect().unit());
00410     newE = newP4.e() - mass;
00411     if(G4HadronicProcess_debug_flag && newE <= 0.0) {
00412       G4ExceptionDescription ed;
00413       DumpState(aT,"Primary has zero energy after interaction",ed);
00414       G4Exception("G4HadronicProcess::FillResults", "had011", JustWarning, ed);
00415     }
00416     if(newE < 0.0) { newE = 0.0; }
00417     theTotalResult->ProposeEnergy( newE );
00418   }
00419 
00420   // check secondaries: apply rotation and Lorentz transformation
00421   G4int nSec = aR->GetNumberOfSecondaries();
00422   theTotalResult->SetNumberOfSecondaries(nSec);
00423   G4double weight = aT.GetWeight();
00424 
00425   if (nSec > 0) {
00426     G4double time0 = aT.GetGlobalTime();
00427     for (G4int i = 0; i < nSec; ++i) {
00428       G4LorentzVector theM = aR->GetSecondary(i)->GetParticle()->Get4Momentum();
00429       theM.rotate(rotation, it);
00430       theM *= aR->GetTrafoToLab();
00431       aR->GetSecondary(i)->GetParticle()->Set4Momentum(theM);
00432 
00433       // time of interaction starts from zero
00434       G4double time = aR->GetSecondary(i)->GetTime();
00435       if (time < 0.0) { time = 0.0; }
00436 
00437       // take into account global time
00438       time += time0;
00439 
00440       G4Track* track = new G4Track(aR->GetSecondary(i)->GetParticle(),
00441                                    time, aT.GetPosition());
00442       G4double newWeight = weight*aR->GetSecondary(i)->GetWeight();
00443         // G4cout << "#### ParticleDebug "
00444         // <<GetProcessName()<<" "
00445         // <<aR->GetSecondary(i)->GetParticle()->GetDefinition()->GetParticleName()<<" "
00446         // <<aScaleFactor<<" "
00447         // <<XBiasSurvivalProbability()<<" "
00448         // <<XBiasSecondaryWeight()<<" "
00449         // <<aT.GetWeight()<<" "
00450         // <<aR->GetSecondary(i)->GetWeight()<<" "
00451         // <<aR->GetSecondary(i)->GetParticle()->Get4Momentum()<<" "
00452         // <<G4endl;
00453       track->SetWeight(newWeight);
00454       track->SetTouchableHandle(aT.GetTouchableHandle());
00455       theTotalResult->AddSecondary(track);
00456       if (G4HadronicProcess_debug_flag) {
00457         G4double e = track->GetKineticEnergy();
00458         if (e <= 0.0) {
00459           G4ExceptionDescription ed;
00460           DumpState(aT,"Secondary has zero energy",ed);
00461           ed << "Secondary " << track->GetDefinition()->GetParticleName()
00462              << G4endl;
00463           G4Exception("G4HadronicProcess::FillResults", "had011", JustWarning,ed);
00464         }
00465       }
00466     }
00467   }
00468 
00469   aR->Clear();
00470   return;
00471 }

G4CrossSectionDataStore* G4HadronicProcess::GetCrossSectionDataStore (  )  [inline]

Definition at line 170 of file G4HadronicProcess.hh.

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

00171     {return theCrossSectionDataStore;}

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

Reimplemented in G4ChargeExchangeProcess.

Definition at line 86 of file G4HadronicProcess.hh.

References G4CrossSectionDataStore::GetCrossSection().

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

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

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

Definition at line 166 of file G4HadronicProcess.hh.

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

00167   { return epCheckLevels; }

const G4EnergyRangeManager& G4HadronicProcess::GetEnergyRangeManager (  )  const [inline, protected]

Definition at line 181 of file G4HadronicProcess.hh.

00182   { return theEnergyRangeManager; }

G4HadronicInteraction* G4HadronicProcess::GetHadronicInteraction (  )  const [inline, protected]

Definition at line 189 of file G4HadronicProcess.hh.

Referenced by CheckEnergyMomentumConservation(), and CheckResult().

00190   { return theInteraction; }

G4double G4HadronicProcess::GetLastCrossSection (  )  [inline, protected]

Definition at line 193 of file G4HadronicProcess.hh.

00194   { return theLastCrossSection; }

G4EnergyRangeManager* G4HadronicProcess::GetManagerPointer (  )  [inline]

Definition at line 121 of file G4HadronicProcess.hh.

Referenced by RegisterMe().

00122   { return &theEnergyRangeManager; }

G4double G4HadronicProcess::GetMeanFreePath ( const G4Track aTrack,
G4double  ,
G4ForceCondition  
) [virtual]

Implements G4VDiscreteProcess.

Definition at line 184 of file G4HadronicProcess.cc.

References DBL_MAX, DumpState(), FatalException, G4endl, G4Exception(), G4CrossSectionDataStore::GetCrossSection(), G4Track::GetDynamicParticle(), G4Track::GetMaterial(), and G4HadronicException::Report().

00185 {
00186   try
00187   {
00188     theLastCrossSection = aScaleFactor*
00189       theCrossSectionDataStore->GetCrossSection(aTrack.GetDynamicParticle(),
00190                                                 aTrack.GetMaterial());
00191   }
00192   catch(G4HadronicException aR)
00193   {
00194     G4ExceptionDescription ed;
00195     aR.Report(ed);
00196     DumpState(aTrack,"GetMeanFreePath",ed);
00197     ed << " Cross section is not available" << G4endl;
00198     G4Exception("G4HadronicProcess::GetMeanFreePath", "had002", FatalException,
00199                 ed);
00200   }
00201   G4double res = DBL_MAX;
00202   if( theLastCrossSection > 0.0 ) { res = 1.0/theLastCrossSection; }
00203   return res;
00204 }

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

Definition at line 97 of file G4HadronicProcess.hh.

References GetElementCrossSection().

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

const G4Isotope* G4HadronicProcess::GetTargetIsotope (  )  [inline]

Definition at line 133 of file G4HadronicProcess.hh.

References G4Nucleus::GetIsotope().

00134   { return targetNucleus.GetIsotope(); }

const G4Nucleus* G4HadronicProcess::GetTargetNucleus (  )  const [inline]

Definition at line 129 of file G4HadronicProcess.hh.

00130   { return &targetNucleus; }

G4Nucleus* G4HadronicProcess::GetTargetNucleusPointer (  )  [inline, protected]

Definition at line 149 of file G4HadronicProcess.hh.

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

00150   { return &targetNucleus; }

void G4HadronicProcess::MultiplyCrossSectionBy ( G4double  factor  )  [inline]

Definition at line 173 of file G4HadronicProcess.hh.

00174   { aScaleFactor = factor; }

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.

References G4HadronicInteraction::ApplyYourself(), CheckEnergyMomentumConservation(), CheckResult(), ChooseHadronicInteraction(), G4VParticleChange::Clear(), G4VProcess::ClearNumberOfInteractionLengthLeft(), DumpState(), epReportLevel, fAlive, FatalException, FillResult(), fKillTrackAndSecondaries, fPostponeToNextEvent, fStopAndKill, fSuspend, G4endl, G4Exception(), G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetBaryonNumber(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), GetElementCrossSection(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterial(), G4HadronicInteraction::GetModelName(), G4Element::GetName(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetPDGCharge(), G4Track::GetTrackStatus(), G4HadProjectile::GetTrafoToLab(), G4Track::GetWeight(), G4Nucleus::GetZ_asInt(), G4HadProjectile::Initialise(), G4ParticleChange::Initialize(), JustWarning, G4VParticleChange::ProposeWeight(), G4HadronicException::Report(), G4CrossSectionDataStore::SampleZandA(), G4HadFinalState::SetTrafoToLab(), thePro, and theTotalResult.

00208 {
00209   // if primary is not Alive then do nothing
00210   theTotalResult->Clear();
00211   theTotalResult->Initialize(aTrack);
00212   theTotalResult->ProposeWeight(aTrack.GetWeight());
00213   if(aTrack.GetTrackStatus() != fAlive) { return theTotalResult; }
00214 
00215   // Find cross section at end of step and check if <= 0
00216   //
00217   const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
00218   G4Material* aMaterial = aTrack.GetMaterial();
00219 
00220   G4Element* anElement = 0;
00221   try
00222   {
00223      anElement = theCrossSectionDataStore->SampleZandA(aParticle,
00224                                                        aMaterial,
00225                                                        targetNucleus);
00226   }
00227   catch(G4HadronicException & aR)
00228   {
00229     G4ExceptionDescription ed;
00230     aR.Report(ed);
00231     DumpState(aTrack,"SampleZandA",ed);
00232     ed << " PostStepDoIt failed on element selection" << G4endl;
00233     G4Exception("G4HadronicProcess::PostStepDoIt", "had003", FatalException,
00234                 ed);
00235   }
00236 
00237   // check only for charged particles
00238   if(aParticle->GetDefinition()->GetPDGCharge() != 0.0) {
00239     if (GetElementCrossSection(aParticle, anElement, aMaterial) <= 0.0) {
00240       // No interaction
00241       return theTotalResult;
00242     }    
00243   }
00244 
00245   // Next check for illegal track status
00246   //
00247   if (aTrack.GetTrackStatus() != fAlive && aTrack.GetTrackStatus() != fSuspend) {
00248     if (aTrack.GetTrackStatus() == fStopAndKill ||
00249         aTrack.GetTrackStatus() == fKillTrackAndSecondaries ||
00250         aTrack.GetTrackStatus() == fPostponeToNextEvent) {
00251       G4ExceptionDescription ed;
00252       ed << "G4HadronicProcess: track in unusable state - "
00253          << aTrack.GetTrackStatus() << G4endl;
00254       ed << "G4HadronicProcess: returning unchanged track " << G4endl;
00255       DumpState(aTrack,"PostStepDoIt",ed);
00256       G4Exception("G4HadronicProcess::PostStepDoIt", "had004", JustWarning, ed);
00257     }
00258     // No warning for fStopButAlive which is a legal status here
00259     return theTotalResult;
00260   }
00261 
00262   // Go on to regular case
00263   //
00264   G4double originalEnergy = aParticle->GetKineticEnergy();
00265   G4double kineticEnergy = originalEnergy;
00266 
00267   // Get kinetic energy per nucleon for ions
00268   if(aParticle->GetParticleDefinition()->GetBaryonNumber() > 1.5)
00269           kineticEnergy/=aParticle->GetParticleDefinition()->GetBaryonNumber();
00270 
00271   try
00272   {
00273     theInteraction =
00274       ChooseHadronicInteraction( kineticEnergy, aMaterial, anElement );
00275   }
00276   catch(G4HadronicException & aE)
00277   {
00278     G4ExceptionDescription ed;
00279     aE.Report(ed);
00280     ed << "Target element "<<anElement->GetName()<<"  Z= "
00281        << targetNucleus.GetZ_asInt() << "  A= "
00282        << targetNucleus.GetA_asInt() << G4endl;
00283     DumpState(aTrack,"ChooseHadronicInteraction",ed);
00284     ed << " No HadronicInteraction found out" << G4endl;
00285     G4Exception("G4HadronicProcess::PostStepDoIt", "had005", FatalException,
00286                 ed);
00287   }
00288 
00289   // Initialize the hadronic projectile from the track
00290   thePro.Initialise(aTrack);
00291   G4HadFinalState* result = 0;
00292   G4int reentryCount = 0;
00293 
00294   do
00295   {
00296     try
00297     {
00298       // Save random engine if requested for debugging
00299       if (G4Hadronic_Random_File) {
00300          CLHEP::HepRandom::saveEngineStatus(G4Hadronic_Random_File);
00301       }
00302       // Call the interaction
00303       result = theInteraction->ApplyYourself( thePro, targetNucleus);
00304       ++reentryCount;
00305     }
00306     catch(G4HadronicException aR)
00307     {
00308       G4ExceptionDescription ed;
00309       aR.Report(ed);
00310       ed << "Call for " << theInteraction->GetModelName() << G4endl;
00311       ed << "Target element "<<anElement->GetName()<<"  Z= "
00312          << targetNucleus.GetZ_asInt()
00313          << "  A= " << targetNucleus.GetA_asInt() << G4endl;
00314       DumpState(aTrack,"ApplyYourself",ed);
00315       ed << " ApplyYourself failed" << G4endl;
00316       G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
00317                   ed);
00318     }
00319 
00320     // Check the result for catastrophic energy non-conservation
00321     result = CheckResult(thePro,targetNucleus, result);
00322 
00323     if(reentryCount>100) {
00324       G4ExceptionDescription ed;
00325       ed << "Call for " << theInteraction->GetModelName() << G4endl;
00326       ed << "Target element "<<anElement->GetName()<<"  Z= "
00327          << targetNucleus.GetZ_asInt()
00328          << "  A= " << targetNucleus.GetA_asInt() << G4endl;
00329       DumpState(aTrack,"ApplyYourself",ed);
00330       ed << " ApplyYourself does not completed after 100 attempts" << G4endl;
00331       G4Exception("G4HadronicProcess::PostStepDoIt", "had006", FatalException,
00332                   ed);
00333     }
00334   }
00335   while(!result);
00336 
00337   result->SetTrafoToLab(thePro.GetTrafoToLab());
00338 
00339   ClearNumberOfInteractionLengthLeft();
00340 
00341   FillResult(result, aTrack);
00342 
00343   if (epReportLevel != 0) {
00344     CheckEnergyMomentumConservation(aTrack, targetNucleus);
00345   }
00346   return theTotalResult;
00347 }

void G4HadronicProcess::PreparePhysicsTable ( const G4ParticleDefinition  )  [virtual]

Reimplemented from G4VProcess.

Reimplemented in G4HadronElasticProcess, and G4HadronStoppingProcess.

Definition at line 158 of file G4HadronicProcess.cc.

References G4HadronicProcessStore::Instance(), and G4HadronicProcessStore::RegisterParticle().

Referenced by G4HadronElasticProcess::PreparePhysicsTable().

00159 {
00160   if(getenv("G4HadronicProcess_debug")) {
00161     G4HadronicProcess_debug_flag = true;
00162   }
00163   G4HadronicProcessStore::Instance()->RegisterParticle(this, &p);
00164 }

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.

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

void G4HadronicProcess::RegisterMe ( G4HadronicInteraction a  ) 

Definition at line 142 of file G4HadronicProcess.cc.

References FatalException, G4endl, G4Exception(), GetManagerPointer(), G4HadronicInteraction::GetModelName(), G4VProcess::GetProcessName(), G4HadronicProcessStore::Instance(), G4HadronicProcessStore::RegisterInteraction(), G4EnergyRangeManager::RegisterMe(), and G4HadronicException::Report().

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

00143 {
00144   if(!a) { return; }
00145   try{GetManagerPointer()->RegisterMe( a );}
00146   catch(G4HadronicException & aE)
00147   {
00148     G4ExceptionDescription ed;
00149     aE.Report(ed);
00150     ed << "Unrecoverable error in " << GetProcessName()
00151        << " to register " << a->GetModelName() << G4endl;
00152     G4Exception("G4HadronicProcess::RegisterMe", "had001", FatalException,
00153                 ed);
00154   }
00155   G4HadronicProcessStore::Instance()->RegisterInteraction(this, a);
00156 }

void G4HadronicProcess::SetEnergyMomentumCheckLevels ( G4double  relativeLevel,
G4double  absoluteLevel 
) [inline]

Definition at line 160 of file G4HadronicProcess.hh.

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

00161   { epCheckLevels.first = relativeLevel;
00162     epCheckLevels.second = absoluteLevel;
00163     levelsSetByProcess = true;
00164   }

void G4HadronicProcess::SetEnergyRangeManager ( const G4EnergyRangeManager value  )  [inline, protected]

Definition at line 185 of file G4HadronicProcess.hh.

00186   { theEnergyRangeManager = value; }

void G4HadronicProcess::SetEpReportLevel ( G4int  level  )  [inline]

Definition at line 157 of file G4HadronicProcess.hh.

References epReportLevel.

00158   { epReportLevel = level; }


Field Documentation

G4int G4HadronicProcess::epReportLevel [protected]

Definition at line 224 of file G4HadronicProcess.hh.

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

G4HadProjectile G4HadronicProcess::thePro [protected]

Definition at line 220 of file G4HadronicProcess.hh.

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

G4ParticleChange* G4HadronicProcess::theTotalResult [protected]

Definition at line 222 of file G4HadronicProcess.hh.

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


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:08 2013 for Geant4 by  doxygen 1.4.7