Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4PreCompoundModel Class Reference

#include <G4PreCompoundModel.hh>

Inheritance diagram for G4PreCompoundModel:
Collaboration diagram for G4PreCompoundModel:

Public Member Functions

 G4PreCompoundModel (G4ExcitationHandler *ptr=nullptr)
 
virtual ~G4PreCompoundModel ()
 
virtual G4HadFinalStateApplyYourself (const G4HadProjectile &thePrimary, G4Nucleus &theNucleus) final
 
virtual G4ReactionProductVectorDeExcite (G4Fragment &aFragment) final
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &) final
 
virtual void InitialiseModel () final
 
virtual void ModelDescription (std::ostream &outFile) const final
 
virtual void DeExciteModelDescription (std::ostream &outFile) const final
 
void UseHETCEmission ()
 
void UseDefaultEmission ()
 
void UseGNASHTransition ()
 
void UseDefaultTransition ()
 
void SetOPTxs (G4int opt)
 
void UseSICB ()
 
void UseNGB ()
 
void UseSCO ()
 
void UseCEMtr ()
 
- Public Member Functions inherited from G4VPreCompoundModel
 G4VPreCompoundModel (G4ExcitationHandler *ptr=nullptr, const G4String &modelName="PrecompoundModel")
 
virtual ~G4VPreCompoundModel ()
 
void SetExcitationHandler (G4ExcitationHandler *ptr)
 
G4ExcitationHandlerGetExcitationHandler () const
 
- Public Member Functions inherited from G4HadronicInteraction
 G4HadronicInteraction (const G4String &modelName="HadronicModel")
 
virtual ~G4HadronicInteraction ()
 
virtual G4double SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
 
virtual G4bool IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
 
G4double GetMinEnergy () const
 
G4double GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
void SetMinEnergy (G4double anEnergy)
 
void SetMinEnergy (G4double anEnergy, const G4Element *anElement)
 
void SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)
 
G4double GetMaxEnergy () const
 
G4double GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
 
void SetMaxEnergy (const G4double anEnergy)
 
void SetMaxEnergy (G4double anEnergy, const G4Element *anElement)
 
void SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)
 
G4int GetVerboseLevel () const
 
void SetVerboseLevel (G4int value)
 
const G4StringGetModelName () const
 
void DeActivateFor (const G4Material *aMaterial)
 
void ActivateFor (const G4Material *aMaterial)
 
void DeActivateFor (const G4Element *anElement)
 
void ActivateFor (const G4Element *anElement)
 
G4bool IsBlocked (const G4Material *aMaterial) const
 
G4bool IsBlocked (const G4Element *anElement) const
 
void SetRecoilEnergyThreshold (G4double val)
 
G4double GetRecoilEnergyThreshold () const
 
virtual const std::pair
< G4double, G4double
GetFatalEnergyCheckLevels () const
 
virtual std::pair< G4double,
G4double
GetEnergyMomentumCheckLevels () const
 
void SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
 

Additional Inherited Members

- Protected Member Functions inherited from G4HadronicInteraction
void SetModelName (const G4String &nam)
 
G4bool IsBlocked () const
 
void Block ()
 
- Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState theParticleChange
 
G4int verboseLevel
 
G4double theMinEnergy
 
G4double theMaxEnergy
 
G4bool isBlocked
 

Detailed Description

Definition at line 63 of file G4PreCompoundModel.hh.

Constructor & Destructor Documentation

G4PreCompoundModel::G4PreCompoundModel ( G4ExcitationHandler ptr = nullptr)
explicit

Definition at line 71 of file G4PreCompoundModel.cc.

72  : G4VPreCompoundModel(ptr,"PRECO"),theEmission(nullptr),theTransition(nullptr),
73  useSCO(false),isInitialised(false),minZ(3),minA(5)
74 {
75  //G4cout << "### NEW PrecompoundModel " << this << G4endl;
76  if(!ptr) { SetExcitationHandler(new G4ExcitationHandler()); }
77 
78  proton = G4Proton::Proton();
79  neutron = G4Neutron::Neutron();
80  fLevelDensity = fLimitEnergy = 0.0;
81 }
G4VPreCompoundModel(G4ExcitationHandler *ptr=nullptr, const G4String &modelName="PrecompoundModel")
void SetExcitationHandler(G4ExcitationHandler *ptr)
static G4Proton * Proton()
Definition: G4Proton.cc:93
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104

Here is the call graph for this function:

G4PreCompoundModel::~G4PreCompoundModel ( )
virtual

Definition at line 85 of file G4PreCompoundModel.cc.

86 {
87  delete theEmission;
88  delete theTransition;
89  delete GetExcitationHandler();
90 }
G4ExcitationHandler * GetExcitationHandler() const

Here is the call graph for this function:

Member Function Documentation

G4HadFinalState * G4PreCompoundModel::ApplyYourself ( const G4HadProjectile thePrimary,
G4Nucleus theNucleus 
)
finalvirtual

Implements G4HadronicInteraction.

Definition at line 136 of file G4PreCompoundModel.cc.

138 {
139  const G4ParticleDefinition* primary = thePrimary.GetDefinition();
140  if(primary != neutron && primary != proton) {
142  ed << "G4PreCompoundModel is used for ";
143  if(primary) { ed << primary->GetParticleName(); }
144  G4Exception("G4PreCompoundModel::ApplyYourself()","had0033",FatalException,
145  ed,"");
146  return 0;
147  }
148 
149  G4int Zp = 0;
150  G4int Ap = 1;
151  if(primary == proton) { Zp = 1; }
152 
153  G4int A = theNucleus.GetA_asInt();
154  G4int Z = theNucleus.GetZ_asInt();
155 
156  //G4cout << "### G4PreCompoundModel::ApplyYourself: A= " << A << " Z= " << Z
157  // << " Ap= " << Ap << " Zp= " << Zp << G4endl;
158  // 4-Momentum
159  G4LorentzVector p = thePrimary.Get4Momentum();
161  p += G4LorentzVector(0.0,0.0,0.0,mass);
162  //G4cout << "Primary 4-mom " << p << " mass= " << mass << G4endl;
163 
164  // prepare fragment
165  G4Fragment anInitialState(A + Ap, Z + Zp, p);
166  anInitialState.SetNumberOfExcitedParticle(2, 1);
167  anInitialState.SetNumberOfHoles(1,0);
168  anInitialState.SetCreationTime(thePrimary.GetGlobalTime());
169 
170  // call excitation handler
171  G4ReactionProductVector * result = DeExcite(anInitialState);
172 
173  // fill particle change
174  theResult.Clear();
175  theResult.SetStatusChange(stopAndKill);
176  for(G4ReactionProductVector::iterator i= result->begin();
177  i != result->end(); ++i)
178  {
179  G4DynamicParticle * aNew =
180  new G4DynamicParticle((*i)->GetDefinition(),
181  (*i)->GetTotalEnergy(),
182  (*i)->GetMomentum());
183  delete (*i);
184  theResult.AddSecondary(aNew);
185  }
186  delete result;
187 
188  //return the filled particle change
189  return &theResult;
190 }
G4double G4ParticleHPJENDLHEData::G4double result
G4int GetA_asInt() const
Definition: G4Nucleus.hh:109
static G4double GetNuclearMass(const G4double A, const G4double Z)
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
const char * p
Definition: xmltok.h:285
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
void SetStatusChange(G4HadFinalStateStatus aS)
std::vector< G4ReactionProduct * > G4ReactionProductVector
double A(double temperature)
const G4ParticleDefinition * GetDefinition() const
G4double GetGlobalTime() const
const G4LorentzVector & Get4Momentum() const
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4int GetZ_asInt() const
Definition: G4Nucleus.hh:115
void AddSecondary(G4DynamicParticle *aP, G4int mod=-1)
double G4double
Definition: G4Types.hh:76
virtual G4ReactionProductVector * DeExcite(G4Fragment &aFragment) final
CLHEP::HepLorentzVector G4LorentzVector

Here is the call graph for this function:

void G4PreCompoundModel::BuildPhysicsTable ( const G4ParticleDefinition )
finalvirtual

Reimplemented from G4HadronicInteraction.

Definition at line 94 of file G4PreCompoundModel.cc.

95 {
97 }
virtual void InitialiseModel() final

Here is the call graph for this function:

G4ReactionProductVector * G4PreCompoundModel::DeExcite ( G4Fragment aFragment)
finalvirtual

Implements G4VPreCompoundModel.

Definition at line 194 of file G4PreCompoundModel.cc.

195 {
196  if(!isInitialised) { InitialiseModel(); }
197 
199  G4double Eex = aFragment.GetExcitationEnergy();
200  G4int Z = aFragment.GetZ_asInt();
201  G4int A = aFragment.GetA_asInt();
202 
203  //G4cout << "### G4PreCompoundModel::DeExcite" << G4endl;
204  //G4cout << aFragment << G4endl;
205 
206  // Perform Equilibrium Emission
207  if ((Z < minZ && A < minA) || Eex < fLimitEnergy*A) {
208  PerformEquilibriumEmission(aFragment, Result);
209  return Result;
210  }
211 
212  // main loop
213  G4int count = 0;
214  static const G4int countmax = 1000;
215  for (;;) {
216  //G4cout << "### PreCompound loop over fragment" << G4endl;
217  //G4cout << aFragment << G4endl;
218  G4int EquilibriumExcitonNumber =
219  G4lrint(std::sqrt(aFragment.GetExcitationEnergy()
220  *aFragment.GetA_asInt()*fLevelDensity));
221  //
222  // G4cout<<"Neq="<<EquilibriumExcitonNumber<<G4endl;
223  //
224  // J. M. Quesada (Jan. 08) equilibrium hole number could be used as preeq.
225  // evap. delimiter (IAEA report)
226 
227  // Loop for transitions, it is performed while there are
228  // preequilibrium transitions.
229  G4bool ThereIsTransition = false;
230 
231  // G4cout<<"----------------------------------------"<<G4endl;
232  // G4double NP=aFragment.GetNumberOfParticles();
233  // G4double NH=aFragment.GetNumberOfHoles();
234  // G4double NE=aFragment.GetNumberOfExcitons();
235  // G4cout<<" Ex. Energy="<<aFragment.GetExcitationEnergy()<<G4endl;
236  // G4cout<<"N. excitons="<<NE<<" N. Part="<<NP<<"N. Holes ="<<NH<<G4endl;
237  do {
238  ++count;
239  //G4cout<<"transition number .."<<count
240  // <<" n ="<<aFragment.GetNumberOfExcitons()<<G4endl;
241  G4bool go_ahead = false;
242  // soft cutoff criterium as an "ad-hoc" solution to force
243  // increase in evaporation
244  G4int test = aFragment.GetNumberOfExcitons();
245  if (test <= EquilibriumExcitonNumber) { go_ahead=true; }
246 
247  //J. M. Quesada (Apr. 08): soft-cutoff switched off by default
248  if (useSCO && go_ahead)
249  {
250  G4double x = G4double(test)/G4double(EquilibriumExcitonNumber) - 1;
251  if( G4UniformRand() < 1.0 - G4Exp(-x*x/0.32) ) { go_ahead = false; }
252  }
253 
254  // JMQ: WARNING: CalculateProbability MUST be called prior to Get!!
255  // (O values would be returned otherwise)
256  G4double TotalTransitionProbability =
257  theTransition->CalculateProbability(aFragment);
258  G4double P1 = theTransition->GetTransitionProb1();
259  G4double P2 = theTransition->GetTransitionProb2();
260  G4double P3 = theTransition->GetTransitionProb3();
261  //G4cout<<"#0 P1="<<P1<<" P2="<<P2<<" P3="<<P3<<G4endl;
262 
263  //J.M. Quesada (May 2008) Physical criterium (lamdas) PREVAILS over
264  // approximation (critical exciton number)
265  //V.Ivanchenko (May 2011) added check on number of nucleons
266  // to send a fragment to FermiBreakUp
267  if(!go_ahead || P1 <= P2+P3 ||
268  aFragment.GetZ_asInt() < minZ || aFragment.GetA_asInt() < minA ||
269  (aFragment.GetExcitationEnergy() <= fLimitEnergy*aFragment.GetA_asInt()))
270  {
271  //G4cout<<"#4 EquilibriumEmission"<<G4endl;
272  PerformEquilibriumEmission(aFragment,Result);
273  return Result;
274  }
275  else
276  {
277  //
278  // Check if number of excitons is greater than 0
279  // else perform equilibrium emission
280  if (aFragment.GetNumberOfExcitons() <= 0)
281  {
282  PerformEquilibriumEmission(aFragment,Result);
283  return Result;
284  }
285 
286  G4double TotalEmissionProbability =
287  theEmission->GetTotalProbability(aFragment);
288  //
289  //G4cout<<"#1 TotalEmissionProbability="<<TotalEmissionProbability
290  // <<" Nex= " <<aFragment.GetNumberOfExcitons()<<G4endl;
291  //J.M.Quesada (May 08) this has already been done in order to decide
292  // what to do (preeq-eq)
293  // Sum of all probabilities
294  G4double TotalProbability = TotalEmissionProbability
295  + TotalTransitionProbability;
296 
297  // Select subprocess
298  if (TotalProbability*G4UniformRand() > TotalEmissionProbability)
299  {
300  //G4cout<<"#2 Transition"<<G4endl;
301  // It will be transition to state with a new number of excitons
302  ThereIsTransition = true;
303  // Perform the transition
304  theTransition->PerformTransition(aFragment);
305  }
306  else
307  {
308  //G4cout<<"#3 Emission"<<G4endl;
309  // It will be fragment emission
310  ThereIsTransition = false;
311  Result->push_back(theEmission->PerformEmission(aFragment));
312  }
313  }
314  // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
315  } while (ThereIsTransition); // end of do loop
316 
317  // stop if too many iterations
318  if(count >= countmax) {
320  ed << "G4PreCompoundModel loop over " << countmax << " iterations; "
321  << "current G4Fragment: \n" << aFragment;
322  G4Exception("G4PreCompoundModel::DeExcite()","had0034",JustWarning,
323  ed,"");
324  PerformEquilibriumEmission(aFragment, Result);
325  return Result;
326  }
327  } // end of for (;;) loop
328  return Result;
329 }
virtual void PerformTransition(G4Fragment &aFragment)=0
static const G4double * P1[nN]
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
tuple x
Definition: test.py:50
int G4int
Definition: G4Types.hh:78
std::vector< G4ReactionProduct * > G4ReactionProductVector
#define G4UniformRand()
Definition: Randomize.hh:97
double A(double temperature)
G4int GetA_asInt() const
Definition: G4Fragment.hh:266
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
virtual G4double CalculateProbability(const G4Fragment &aFragment)=0
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
G4ReactionProduct * PerformEmission(G4Fragment &aFragment)
G4int GetNumberOfExcitons() const
Definition: G4Fragment.hh:340
int G4lrint(double ad)
Definition: templates.hh:163
virtual void InitialiseModel() final
G4int GetZ_asInt() const
Definition: G4Fragment.hh:271
static const G4double * P2[nN]
double G4double
Definition: G4Types.hh:76
program test
Definition: Main_HIJING.f:1
G4double GetExcitationEnergy() const
Definition: G4Fragment.hh:283
G4double GetTotalProbability(const G4Fragment &aFragment)

Here is the call graph for this function:

Here is the caller graph for this function:

void G4PreCompoundModel::DeExciteModelDescription ( std::ostream &  outFile) const
finalvirtual

Implements G4VPreCompoundModel.

Definition at line 418 of file G4PreCompoundModel.cc.

419 {
420  outFile << "description of precompound model as used with DeExcite()" << "\n";
421 }
void G4PreCompoundModel::InitialiseModel ( )
finalvirtual

Reimplemented from G4HadronicInteraction.

Definition at line 101 of file G4PreCompoundModel.cc.

102 {
103  if(isInitialised) { return; }
104  isInitialised = true;
105 
106  //G4cout << "G4PreCompoundModel::InitialiseModel() started" << G4endl;
107 
108  G4DeexPrecoParameters* param =
110 
111  // 12/pi2 factor is used in real computation
112  fLevelDensity = param->GetLevelDensity()*12.0/CLHEP::pi2;
113  fLimitEnergy = param->GetPrecoLowEnergy();
114 
115  useSCO = param->UseSoftCutoff();
116 
117  minZ = param->GetMinZForPreco();
118  minA = param->GetMinAForPreco();
119 
120  theEmission = new G4PreCompoundEmission();
121  if(param->UseHETC()) { theEmission->SetHETCModel(); }
122  else { theEmission->SetDefaultModel(); }
123  theEmission->SetOPTxs(param->GetPrecoModelType());
124 
125  if(param->UseGNASH()) { theTransition = new G4GNASHTransitions; }
126  else { theTransition = new G4PreCompoundTransitions(); }
127  theTransition->UseNGB(param->NeverGoBack());
128  theTransition->UseCEMtr(param->UseCEM());
129 
131 }
G4double GetPrecoLowEnergy() const
static constexpr double pi2
Definition: SystemOfUnits.h:57
G4double GetLevelDensity() const
G4ExcitationHandler * GetExcitationHandler() const
G4DeexPrecoParameters * GetParameters()
static G4NuclearLevelData * GetInstance()

Here is the call graph for this function:

Here is the caller graph for this function:

void G4PreCompoundModel::ModelDescription ( std::ostream &  outFile) const
finalvirtual

Reimplemented from G4HadronicInteraction.

Definition at line 394 of file G4PreCompoundModel.cc.

395 {
396  outFile
397  << "The GEANT4 precompound model is considered as an extension of the\n"
398  << "hadron kinetic model. It gives a possibility to extend the low energy range\n"
399  << "of the hadron kinetic model for nucleon-nucleus inelastic collision and it \n"
400  << "provides a ”smooth” transition from kinetic stage of reaction described by the\n"
401  << "hadron kinetic model to the equilibrium stage of reaction described by the\n"
402  << "equilibrium deexcitation models.\n"
403  << "The initial information for calculation of pre-compound nuclear stage\n"
404  << "consists of the atomic mass number A, charge Z of residual nucleus, its\n"
405  << "four momentum P0 , excitation energy U and number of excitons n, which equals\n"
406  << "the sum of the number of particles p (from them p_Z are charged) and the number of\n"
407  << "holes h.\n"
408  << "At the preequilibrium stage of reaction, we follow the exciton model approach in ref. [1],\n"
409  << "taking into account the competition among all possible nuclear transitions\n"
410  << "with ∆n = +2, −2, 0 (which are defined by their associated transition probabilities) and\n"
411  << "the emission of neutrons, protons, deutrons, thritium and helium nuclei (also defined by\n"
412  << "their associated emission probabilities according to exciton model)\n"
413  << "\n"
414  << "[1] K.K. Gudima, S.G. Mashnik, V.D. Toneev, Nucl. Phys. A401 329 (1983)\n"
415  << "\n";
416 }
void G4PreCompoundModel::SetOPTxs ( G4int  opt)

Definition at line 355 of file G4PreCompoundModel.cc.

356 {
357  PrintWarning("UseOPTxs");
358 }
void G4PreCompoundModel::UseCEMtr ( )

Definition at line 375 of file G4PreCompoundModel.cc.

376 {
377  PrintWarning("UseCEMtr");
378 }
void G4PreCompoundModel::UseDefaultEmission ( )

Definition at line 340 of file G4PreCompoundModel.cc.

341 {
342  PrintWarning("UseDefaultEmission");
343 }
void G4PreCompoundModel::UseDefaultTransition ( )

Definition at line 350 of file G4PreCompoundModel.cc.

351 {
352  PrintWarning("UseDefaultTransition");
353 }
void G4PreCompoundModel::UseGNASHTransition ( )

Definition at line 345 of file G4PreCompoundModel.cc.

346 {
347  PrintWarning("UseGNASHTransition");
348 }
void G4PreCompoundModel::UseHETCEmission ( )

Definition at line 335 of file G4PreCompoundModel.cc.

336 {
337  PrintWarning("UseHETCEmission");
338 }
void G4PreCompoundModel::UseNGB ( )

Definition at line 365 of file G4PreCompoundModel.cc.

366 {
367  PrintWarning("UseNGB");
368 }
void G4PreCompoundModel::UseSCO ( )

Definition at line 370 of file G4PreCompoundModel.cc.

371 {
372  PrintWarning("UseSCO");
373 }
void G4PreCompoundModel::UseSICB ( )

Definition at line 360 of file G4PreCompoundModel.cc.

361 {
362  PrintWarning("UseSICB");
363 }

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