Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4PhotonEvaporation Class Reference

#include <G4PhotonEvaporation.hh>

+ Inheritance diagram for G4PhotonEvaporation:

Public Member Functions

 G4PhotonEvaporation (G4GammaTransition *ptr=nullptr)
 
 ~G4PhotonEvaporation () override
 
void Initialise () override
 
G4Fragment * EmittedFragment (G4Fragment *theNucleus) override
 
G4bool BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus) override
 
G4FragmentVector * BreakItUp (const G4Fragment &theNucleus)
 
G4double GetEmissionProbability (G4Fragment *theNucleus) override
 
G4double ComputeInverseXSection (G4Fragment *theNucleus, G4double kinEnergy) override
 
G4double ComputeProbability (G4Fragment *theNucleus, G4double kinEnergy) override
 
G4double GetFinalLevelEnergy (G4int Z, G4int A, G4double energy)
 
G4double GetUpperLevelEnergy (G4int Z, G4int A)
 
void SetGammaTransition (G4GammaTransition *)
 
void SetICM (G4bool) override
 
void RDMForced (G4bool) override
 
void SetVerboseLevel (G4int verbose)
 
G4int GetVacantShellNumber () const
 
 G4PhotonEvaporation (const G4PhotonEvaporation &right)=delete
 
const G4PhotonEvaporation & operator= (const G4PhotonEvaporation &right)=delete
 
- Public Member Functions inherited from G4VEvaporationChannel
 G4VEvaporationChannel (const G4String &aName="")
 
virtual ~G4VEvaporationChannel ()=default
 
virtual G4double GetEmissionProbability (G4Fragment *theNucleus)=0
 
virtual void Initialise ()
 
virtual G4double GetLifeTime (G4Fragment *theNucleus)
 
virtual G4Fragment * EmittedFragment (G4Fragment *theNucleus)
 
virtual G4bool BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
 
G4FragmentVector * BreakUpFragment (G4Fragment *theNucleus)
 
virtual G4double ComputeInverseXSection (G4Fragment *theNucleus, G4double kinEnergy)
 
virtual G4double ComputeProbability (G4Fragment *theNucleus, G4double kinEnergy)
 
virtual void Dump () const
 
virtual void SetICM (G4bool)
 
virtual void RDMForced (G4bool)
 
void SetOPTxs (G4int opt)
 
void UseSICB (G4bool use)
 
 G4VEvaporationChannel (const G4VEvaporationChannel &right)=delete
 
const G4VEvaporationChannel & operator= (const G4VEvaporationChannel &right)=delete
 
G4bool operator== (const G4VEvaporationChannel &right) const =delete
 
G4bool operator!= (const G4VEvaporationChannel &right) const =delete
 

Additional Inherited Members

- Protected Attributes inherited from G4VEvaporationChannel
G4int OPTxs
 
G4bool useSICB
 

Detailed Description

Definition at line 58 of file G4PhotonEvaporation.hh.

Constructor & Destructor Documentation

◆ G4PhotonEvaporation() [1/2]

G4PhotonEvaporation::G4PhotonEvaporation ( G4GammaTransition *  ptr = nullptr)
explicit

Definition at line 63 of file G4PhotonEvaporation.cc.

64 : fLevelManager(nullptr), fTransition(p), fPolarization(nullptr),
65 fVerbose(1), fPoints(0), vShellNumber(-1), fIndex(0), fSecID(-1),
66 fMaxLifeTime(DBL_MAX),
67 fICM(true), fRDM(false), fSampleTime(true),
68 fCorrelatedGamma(false), isInitialised(false)
69{
70 //G4cout << "### New G4PhotonEvaporation() " << this << G4endl;
71 fNuclearLevelData = G4NuclearLevelData::GetInstance();
72 fTolerance = 20*CLHEP::eV;
73
74 if(!fTransition) { fTransition = new G4GammaTransition(); }
75
76 theA = theZ = fCode = 0;
77 fSecID = G4PhysicsModelCatalog::GetModelID("model_G4PhotonEvaporation");
78 fLevelEnergyMax = fStep = fExcEnergy = fProbability = 0.0;
79
80 for(G4int i=0; i<MAXDEPOINT; ++i) { fCummProbability[i] = 0.0; }
81 if(0.0f == GREnergy[1]) { InitialiseGRData(); }
82}
MAXDEPOINT
const G4int MAXDEPOINT
Definition: G4PhotonEvaporation.hh:53
G4int
int G4int
Definition: G4Types.hh:85
G4NuclearLevelData::GetInstance
static G4NuclearLevelData * GetInstance()
Definition: G4NuclearLevelData.cc:423
G4PhysicsModelCatalog::GetModelID
static G4int GetModelID(const G4int modelIndex)
Definition: G4PhysicsModelCatalog.cc:683
DBL_MAX
#define DBL_MAX
Definition: templates.hh:62

◆ ~G4PhotonEvaporation()

G4PhotonEvaporation::~G4PhotonEvaporation ( )
override

Definition at line 84 of file G4PhotonEvaporation.cc.

85{
86 delete fTransition;
87}

◆ G4PhotonEvaporation() [2/2]

G4PhotonEvaporation::G4PhotonEvaporation ( const G4PhotonEvaporation &  right)
delete

Member Function Documentation

◆ BreakItUp()

G4FragmentVector * G4PhotonEvaporation::BreakItUp ( const G4Fragment &  theNucleus)

Definition at line 177 of file G4PhotonEvaporation.cc.

178{
179 if(fVerbose > 1) {
180 G4cout << "G4PhotonEvaporation::BreakItUp" << G4endl;
181 }
182 G4Fragment* aNucleus = new G4Fragment(nucleus);
183 G4FragmentVector* products = new G4FragmentVector();
184 BreakUpChain(products, aNucleus);
185 aNucleus->SetCreatorModelID(fSecID);
186 products->push_back(aNucleus);
187 return products;
188}
G4FragmentVector
std::vector< G4Fragment * > G4FragmentVector
Definition: G4Fragment.hh:65
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4Fragment::SetCreatorModelID
void SetCreatorModelID(G4int value)
Definition: G4Fragment.hh:433
G4PhotonEvaporation::BreakUpChain
G4bool BreakUpChain(G4FragmentVector *theResult, G4Fragment *theNucleus) override
Definition: G4PhotonEvaporation.cc:190

Referenced by G4LENDCapture::ApplyYourself(), and G4ParticleHPCaptureFS::ApplyYourself().

◆ BreakUpChain()

G4bool G4PhotonEvaporation::BreakUpChain ( G4FragmentVector *  theResult,
G4Fragment *  theNucleus 
)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 190 of file G4PhotonEvaporation.cc.

192{
193 if(!isInitialised) { Initialise(); }
194 if(fVerbose > 1) {
195 G4cout << "G4PhotonEvaporation::BreakUpChain RDM= " << fRDM << " "
196 << *nucleus << G4endl;
197 }
198 G4Fragment* gamma = nullptr;
199 fSampleTime = !fRDM;
200
201 // start decay chain from unpolarized state
202 if(fCorrelatedGamma) {
203 fPolarization = new G4NuclearPolarization(nucleus->GetZ_asInt(),
204 nucleus->GetA_asInt(),
205 nucleus->GetExcitationEnergy());
206 nucleus->SetNuclearPolarization(fPolarization);
207 }
208
209 do {
210 gamma = GenerateGamma(nucleus);
211 if(gamma) {
212 gamma->SetCreatorModelID(fSecID);
213 products->push_back(gamma);
214 if(fVerbose > 2) {
215 G4cout << "G4PhotonEvaporation::BreakUpChain: "
216 << *gamma << G4endl;
217 G4cout << " Residual: " << *nucleus << G4endl;
218 }
219 // for next decays in the chain always sample time
220 fSampleTime = true;
221 }
222 // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
223 } while(gamma);
224
225 // clear nuclear polarization end of chain
226 if(nullptr != fPolarization) {
227 delete fPolarization;
228 fPolarization = nullptr;
229 nucleus->SetNuclearPolarization(fPolarization);
230 }
231 return false;
232}
G4PhotonEvaporation::Initialise
void Initialise() override
Definition: G4PhotonEvaporation.cc:89

Referenced by BreakItUp().

◆ ComputeInverseXSection()

G4double G4PhotonEvaporation::ComputeInverseXSection ( G4Fragment *  theNucleus,
G4double  kinEnergy 
)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 320 of file G4PhotonEvaporation.cc.

321{
322 return 0.0;
323}

◆ ComputeProbability()

G4double G4PhotonEvaporation::ComputeProbability ( G4Fragment *  theNucleus,
G4double  kinEnergy 
)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 326 of file G4PhotonEvaporation.cc.

327{
328 return GetEmissionProbability(theNucleus);
329}
G4PhotonEvaporation::GetEmissionProbability
G4double GetEmissionProbability(G4Fragment *theNucleus) override
Definition: G4PhotonEvaporation.cc:235

◆ EmittedFragment()

G4Fragment * G4PhotonEvaporation::EmittedFragment ( G4Fragment *  theNucleus)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 126 of file G4PhotonEvaporation.cc.

127{
128 if(!isInitialised) { Initialise(); }
129 fSampleTime = !fRDM;
130
131 // potentially external code may set initial polarization
132 // but only for radioactive decay nuclear polarization is considered
133 G4NuclearPolarizationStore* fNucPStore = nullptr;
134 if(fCorrelatedGamma && fRDM) {
135 fNucPStore = G4NuclearPolarizationStore::GetInstance();
136 auto nucp = nucleus->GetNuclearPolarization();
137 if(nullptr != nucp) {
138 fNucPStore->RemoveMe(nucp);
139 }
140 fPolarization = fNucPStore->FindOrBuild(nucleus->GetZ_asInt(),
141 nucleus->GetA_asInt(),
142 nucleus->GetExcitationEnergy());
143 nucleus->SetNuclearPolarization(fPolarization);
144 }
145 if(fVerbose > 2) {
146 G4cout << "G4PhotonEvaporation::EmittedFragment: "
147 << *nucleus << G4endl;
148 if(fPolarization) { G4cout << "NucPolar: " << fPolarization << G4endl; }
149 G4cout << " CorrGamma: " << fCorrelatedGamma << " RDM: " << fRDM
150 << " fPolarization: " << fPolarization << G4endl;
151 }
152 G4Fragment* gamma = GenerateGamma(nucleus);
153
154 if(gamma != nullptr) { gamma->SetCreatorModelID(fSecID); }
155
156 // remove G4NuclearPolarizaton when reach ground state
157 if(fNucPStore && fPolarization && 0 == fIndex) {
158 if(fVerbose > 3) {
159 G4cout << "G4PhotonEvaporation::EmittedFragment: remove "
160 << fPolarization << G4endl;
161 }
162 fNucPStore->RemoveMe(fPolarization);
163 fPolarization = nullptr;
164 nucleus->SetNuclearPolarization(fPolarization);
165 }
166
167 if(fVerbose > 2) {
168 G4cout << "G4PhotonEvaporation::EmittedFragment: RDM= "
169 << fRDM << " done:" << G4endl;
170 if(gamma) { G4cout << *gamma << G4endl; }
171 G4cout << " Residual: " << *nucleus << G4endl;
172 }
173 return gamma;
174}
G4NuclearPolarizationStore::GetInstance
static G4NuclearPolarizationStore * GetInstance()
Definition: G4NuclearPolarizationStore.cc:36
G4NuclearPolarizationStore::RemoveMe
void RemoveMe(G4NuclearPolarization *ptr)
Definition: G4NuclearPolarizationStore.cc:94
G4NuclearPolarizationStore::FindOrBuild
G4NuclearPolarization * FindOrBuild(G4int Z, G4int A, G4double Eexc)
Definition: G4NuclearPolarizationStore.cc:79

Referenced by G4ITDecay::DecayIt().

◆ GetEmissionProbability()

G4double G4PhotonEvaporation::GetEmissionProbability ( G4Fragment *  theNucleus)
overridevirtual

Implements G4VEvaporationChannel.

Definition at line 235 of file G4PhotonEvaporation.cc.

236{
237 if(!isInitialised) { Initialise(); }
238 fProbability = 0.0;
239 fExcEnergy = nucleus->GetExcitationEnergy();
240 G4int Z = nucleus->GetZ_asInt();
241 G4int A = nucleus->GetA_asInt();
242 fCode = 1000*Z + A;
243 if(fVerbose > 2) {
244 G4cout << "G4PhotonEvaporation::GetEmissionProbability: Z="
245 << Z << " A=" << A << " Eexc(MeV)= " << fExcEnergy << G4endl;
246 }
247 // ignore gamma de-excitation for exotic fragments
248 // and for very low excitations
249 if(0 >= Z || 1 >= A || Z == A || fTolerance >= fExcEnergy)
250 { return fProbability; }
251
252 // ignore gamma de-excitation for highly excited levels
253 if(A >= MAXGRDATA) { A = MAXGRDATA-1; }
254 //G4cout<<" GREnergy= "<< GREnergy[A]<<" GRWidth= "<<GRWidth[A]<<G4endl;
255
256 static const G4float GREfactor = 5.0f;
257 if(fExcEnergy >= (G4double)(GREfactor*GRWidth[A] + GREnergy[A])) {
258 return fProbability;
259 }
260 // probability computed assuming continium transitions
261 // VI: continium transition are limited only to final states
262 // below Fermi energy (this approach needs further evaluation)
263 G4double emax = std::max(0.0, nucleus->ComputeGroundStateMass(Z, A-1)
264 + CLHEP::neutron_mass_c2 - nucleus->GetGroundStateMass());
265
266 // max energy level for continues transition
267 emax = std::min(emax, fExcEnergy);
268 const G4double eexcfac = 0.99;
269 if(0.0 == emax || fExcEnergy*eexcfac <= emax) { emax = fExcEnergy*eexcfac; }
270
271 fStep = emax;
272 const G4double MaxDeltaEnergy = CLHEP::MeV;
273 fPoints = std::min((G4int)(fStep/MaxDeltaEnergy) + 2, MAXDEPOINT);
274 fStep /= ((G4double)(fPoints - 1));
275 if(fVerbose > 2) {
276 G4cout << "Emax= " << emax << " Npoints= " << fPoints
277 << " Eex= " << fExcEnergy << G4endl;
278 }
279 // integrate probabilities
280 G4double eres = (G4double)GREnergy[A];
281 G4double wres = (G4double)GRWidth[A];
282 G4double eres2= eres*eres;
283 G4double wres2= wres*wres;
284 G4double levelDensity = fNuclearLevelData->GetLevelDensity(Z,A,fExcEnergy);
285 G4double xsqr = std::sqrt(levelDensity*fExcEnergy);
286
287 G4double egam = fExcEnergy;
288 G4double gammaE2 = egam*egam;
289 G4double gammaR2 = gammaE2*wres2;
290 G4double egdp2 = gammaE2 - eres2;
291
292 G4double p0 = G4Exp(-2.0*xsqr)*gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
293 G4double p1(0.0);
294
295 for(G4int i=1; i<fPoints; ++i) {
296 egam -= fStep;
297 gammaE2 = egam*egam;
298 gammaR2 = gammaE2*wres2;
299 egdp2 = gammaE2 - eres2;
300 p1 = G4Exp(2.0*(std::sqrt(levelDensity*std::abs(fExcEnergy - egam)) - xsqr))
301 *gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
302 fProbability += (p1 + p0);
303 fCummProbability[i] = fProbability;
304 if(fVerbose > 3) {
305 G4cout << "Egamma= " << egam << " Eex= " << fExcEnergy
306 << " p0= " << p0 << " p1= " << p1 << " sum= "
307 << fCummProbability[i] <<G4endl;
308 }
309 p0 = p1;
310 }
311
312 static const G4double NormC = 1.25*CLHEP::millibarn
313 /(CLHEP::pi2*CLHEP::hbarc*CLHEP::hbarc);
314 fProbability *= fStep*NormC*A;
315 if(fVerbose > 1) { G4cout << "prob= " << fProbability << G4endl; }
316 return fProbability;
317}
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:180
MAXGRDATA
const G4int MAXGRDATA
Definition: G4PhotonEvaporation.hh:54
G4float
float G4float
Definition: G4Types.hh:84
G4double
double G4double
Definition: G4Types.hh:83
Z
const G4int Z[17]
Definition: G4WaterStopping.cc:51
A
const G4double A[17]
Definition: G4WaterStopping.cc:53
G4NuclearLevelData::GetLevelDensity
G4double GetLevelDensity(G4int Z, G4int A, G4double U)
Definition: G4NuclearLevelData.cc:620

Referenced by ComputeProbability().

◆ GetFinalLevelEnergy()

G4double G4PhotonEvaporation::GetFinalLevelEnergy ( G4int  Z,
G4int  A,
G4double  energy 
)

Definition at line 332 of file G4PhotonEvaporation.cc.

333{
334 G4double E = energy;
335 InitialiseLevelManager(Z, A);
336 if(fLevelManager) {
337 E = fLevelManager->NearestLevelEnergy(energy, fIndex);
338 if(E > fLevelEnergyMax + fTolerance) { E = energy; }
339 }
340 return E;
341}
G4LevelManager::NearestLevelEnergy
G4double NearestLevelEnergy(const G4double energy, const std::size_t index=0) const
Definition: G4LevelManager.hh:170
G4INCL::KinematicsUtils::energy
G4double energy(const ThreeVector &p, const G4double m)
Definition: G4INCLKinematicsUtils.cc:158

◆ GetUpperLevelEnergy()

G4double G4PhotonEvaporation::GetUpperLevelEnergy ( G4int  Z,
G4int  A 
)

Definition at line 343 of file G4PhotonEvaporation.cc.

344{
345 InitialiseLevelManager(Z, A);
346 return fLevelEnergyMax;
347}

◆ GetVacantShellNumber()

G4int G4PhotonEvaporation::GetVacantShellNumber ( ) const
inline

Definition at line 169 of file G4PhotonEvaporation.hh.

170{
171 return vShellNumber;
172}

Referenced by G4ITDecay::DecayIt().

◆ Initialise()

void G4PhotonEvaporation::Initialise ( )
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 89 of file G4PhotonEvaporation.cc.

90{
91 if(isInitialised) { return; }
92 isInitialised = true;
93
94 G4DeexPrecoParameters* param = fNuclearLevelData->GetParameters();
95 fTolerance = param->GetMinExcitation();
96 fMaxLifeTime = param->GetMaxLifeTime();
97 fCorrelatedGamma = param->CorrelatedGamma();
98 fICM = param->GetInternalConversionFlag();
99 fVerbose = param->GetVerbose();
100
101 fTransition->SetPolarizationFlag(fCorrelatedGamma);
102 fTransition->SetTwoJMAX(param->GetTwoJMAX());
103 fTransition->SetVerbose(fVerbose);
104 if(fVerbose > 1) {
105 G4cout << "### G4PhotonEvaporation is initialized " << this << G4endl;
106 }
107}
G4DeexPrecoParameters::GetMinExcitation
G4double GetMinExcitation() const
Definition: G4DeexPrecoParameters.hh:322
G4DeexPrecoParameters::GetInternalConversionFlag
G4bool GetInternalConversionFlag() const
Definition: G4DeexPrecoParameters.hh:407
G4GammaTransition::SetPolarizationFlag
void SetPolarizationFlag(G4bool val)
Definition: G4GammaTransition.hh:73
G4GammaTransition::SetTwoJMAX
void SetTwoJMAX(G4int val)
Definition: G4GammaTransition.hh:75
G4GammaTransition::SetVerbose
void SetVerbose(G4int val)
Definition: G4GammaTransition.hh:77
G4NuclearLevelData::GetParameters
G4DeexPrecoParameters * GetParameters()
Definition: G4NuclearLevelData.cc:605

Referenced by BreakUpChain(), EmittedFragment(), and GetEmissionProbability().

◆ operator=()

const G4PhotonEvaporation & G4PhotonEvaporation::operator= ( const G4PhotonEvaporation &  right)
delete

◆ RDMForced()

void G4PhotonEvaporation::RDMForced ( G4bool  val)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 585 of file G4PhotonEvaporation.cc.

586{
587 fRDM = val;
588}

Referenced by G4RadioactiveDecay::G4RadioactiveDecay().

◆ SetGammaTransition()

void G4PhotonEvaporation::SetGammaTransition ( G4GammaTransition *  p)

Definition at line 572 of file G4PhotonEvaporation.cc.

573{
574 if(p != fTransition) {
575 delete fTransition;
576 fTransition = p;
577 }
578}

◆ SetICM()

void G4PhotonEvaporation::SetICM ( G4bool  val)
overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 580 of file G4PhotonEvaporation.cc.

581{
582 fICM = val;
583}

Referenced by G4LENDCapture::ApplyYourself(), G4ParticleHPCaptureFS::ApplyYourself(), and G4RadioactiveDecay::G4RadioactiveDecay().

◆ SetVerboseLevel()

void G4PhotonEvaporation::SetVerboseLevel ( G4int  verbose)
inline

Definition at line 152 of file G4PhotonEvaporation.hh.

153{
154 fVerbose = verbose;
155}
The documentation for this class was generated from the following files: