lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.3.1 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2017-02-28 16:18:37 +01:00
parent 4597adb7c4
commit 3a5407696b
563 changed files with 0 additions and 95641 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/dna/utils/include/G4DNADamages.hh
-127
View File
@@ -1,127 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNADamages.hh 85244 2014-10-27 08:24:13Z gcosmo $
//
// Author: Mathieu Karamitros, kara@cenbg.in2p3.fr
// The code is developed in the framework of the ESA AO7146
//
// We would be very happy hearing from you, send us your feedback! :)
//
// In order for Geant4-DNA to be maintained and still open-source,
// article citations are crucial.
// If you use Geant4-DNA chemistry and you publish papers about your software,
// in addition to the general paper on Geant4-DNA:
//
// Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
//
// we would be very happy if you could please also cite the following
// reference papers on chemistry:
//
// J. Comput. Phys. 274 (2014) 841-882
// Prog. Nucl. Sci. Tec. 2 (2011) 503-508
#ifndef G4DNADAMAGES_HH
#define G4DNADAMAGES_HH 1
#include "G4Molecule.hh"
class G4VDNAHit
{
public :
G4VDNAHit(){;}
virtual ~G4VDNAHit(){;}
};
class G4DNAIndirectHit : public G4VDNAHit
{
public :
G4DNAIndirectHit(const G4String& baseName, const G4Molecule* molecule,
const G4ThreeVector& position, G4double time);
virtual ~G4DNAIndirectHit();
inline const G4Molecule* GetMolecule() {return fpMolecule;}
inline const G4ThreeVector& GetPosition() {return fPosition;}
inline const G4String& GetBaseName() {return fBaseName;}
inline double GetTime() {return fTime;}
void Print();
protected :
const G4Molecule* fpMolecule;
G4ThreeVector fPosition;
G4double fTime;
G4String fBaseName;
};
class G4DNADamages
{
public:
static G4DNADamages* Instance();
static void DeleteInstance();
virtual void Reset();
//void AddDirectDamage();
virtual void AddIndirectDamage(const G4String& baseName,const G4Molecule* molecule,
const G4ThreeVector& position, double time);
inline const std::vector<G4DNAIndirectHit*>* GetIndirectHits();
inline virtual int GetNIndirectHits() const
{
if(fJustCountDamage)
return fNIndirectDamages;
return fIndirectHits.size();
}
inline virtual void SetOnlyCountDamages(bool flag = true)
{
fJustCountDamage = flag;
}
inline virtual bool OnlyCountDamages() const
{
return fJustCountDamage;
}
protected :
G4DNADamages();
static G4ThreadLocal G4DNADamages* fpInstance;
virtual ~G4DNADamages();
G4bool fJustCountDamage;
G4int fNIndirectDamages;
std::vector<G4DNAIndirectHit*> fIndirectHits;
std::map<G4Molecule, const G4Molecule*> fMolMap;
};
inline const std::vector<G4DNAIndirectHit*>* G4DNADamages::GetIndirectHits()
{
return &fIndirectHits;
}
#endif // G4DNADAMAGES_HH
source/processes/electromagnetic/dna/utils/src/G4DNADamages.cc
-122
View File
@@ -1,122 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNADamages.cc 85244 2014-10-27 08:24:13Z gcosmo $
//
#include "G4DNADamages.hh"
#include "G4UnitsTable.hh"
G4ThreadLocal G4DNADamages* G4DNADamages::fpInstance(0);
G4DNAIndirectHit::G4DNAIndirectHit(const G4String& baseName,
const G4Molecule* molecule,
const G4ThreeVector& position,
G4double time) :
G4VDNAHit(), fpMolecule(molecule)
{
fBaseName = baseName;
fPosition = position;
fTime = time;
}
G4DNAIndirectHit::~G4DNAIndirectHit()
{
if (fpMolecule) delete fpMolecule;
fpMolecule = 0;
}
void G4DNAIndirectHit::Print()
{
G4cout << "Reaction : " << fpMolecule->GetName() << " + " << fBaseName
<< " at position : " << G4BestUnit(fPosition, "Length")
<< " and time : " << G4BestUnit(fTime, "Time") << G4endl;
}
G4DNADamages* G4DNADamages::Instance()
{
if (!fpInstance) new G4DNADamages();
return fpInstance;
}
G4DNADamages::G4DNADamages()
{
fJustCountDamage = false;
fNIndirectDamages = 0;
fpInstance = this;
}
G4DNADamages::~G4DNADamages()
{
for (int i = 0; i < (int) fIndirectHits.size(); i++)
{
if (fIndirectHits[i]) delete fIndirectHits[i];
}
fIndirectHits.clear();
}
void G4DNADamages::DeleteInstance()
{
if (fpInstance) delete fpInstance;
fpInstance = 0;
}
void G4DNADamages::Reset()
{
fNIndirectDamages = 0;
for (int i = 0; i < (int) fIndirectHits.size(); i++)
{
if (fIndirectHits[i]) delete fIndirectHits[i];
}
fIndirectHits.clear();
}
void G4DNADamages::AddIndirectDamage(const G4String& baseName,
const G4Molecule* molecule,
const G4ThreeVector& position,
G4double time)
{
if (fJustCountDamage)
{
fNIndirectDamages++;
return;
}
G4DNAIndirectHit* indirectHit = 0;
std::map<G4Molecule, const G4Molecule*>::iterator it = fMolMap.find(
*molecule);
if (it == fMolMap.end())
{
G4Molecule* mol(0);
fMolMap[*molecule] = (mol = new G4Molecule(*molecule));
indirectHit = new G4DNAIndirectHit(baseName, mol, position, time);
}
else
{
indirectHit = new G4DNAIndirectHit(baseName, it->second, position, time);
}
fIndirectHits.push_back(indirectHit);
}
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4ContinuumGammaDeexcitation.hh
-80
View File
@@ -1,80 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuumGammaDeexcitation.hh 85841 2014-11-05 15:35:06Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaDeexcitation
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
//
//
// Class G4ContinuumGammaDeexcitation.hh
//
#ifndef G4ContinuumGammaDeexcitation_hh
#define G4ContinuumGammaDeexcitation_hh 1
#include "G4VGammaDeexcitation.hh"
#include "globals.hh"
#include "G4ContinuumGammaTransition.hh"
#include "G4Fragment.hh"
class G4NuclearLevelManager;
class G4NuclearLevelStore;
class G4DiscreteGammaTransition;
class G4ContinuumGammaDeexcitation : public G4VGammaDeexcitation
{
public:
G4ContinuumGammaDeexcitation();
virtual ~G4ContinuumGammaDeexcitation();
virtual G4bool CanDoTransition(G4Fragment* aNucleus);
private:
G4int nucleusZ;
G4int nucleusA;
G4NuclearLevelStore* store;
G4NuclearLevelManager* levelManager;
G4ContinuumGammaTransition* ctransition;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4ContinuumGammaTransition.hh
-106
View File
@@ -1,106 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuumGammaTransition.hh 87017 2014-11-21 16:26:26Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaTransition
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
// 02 May 2003, Vladimir Ivanchenko change interface to G4NuclearlevelManager
//
// -------------------------------------------------------------------
//
// Header file for G4ContinuumGammaTransition
//
#ifndef G4ContinuumGammaTransition_hh
#define G4ContinuumGammaTransition_hh 1
#include "globals.hh"
#include "G4VGammaTransition.hh"
#include "G4ConstantLevelDensityParameter.hh"
#include <vector>
class G4NuclearLevelManager;
class G4Pow;
class G4ContinuumGammaTransition : public G4VGammaTransition
{
public:
G4ContinuumGammaTransition(const G4NuclearLevelManager* manager,
G4int Z, G4int A, G4double exc, G4int ver);
virtual ~G4ContinuumGammaTransition();
virtual void SetEnergyFrom(G4double energy);
virtual G4double GetGammaEnergy();
virtual G4double GetGammaCreationTime();
virtual void SelectGamma();
void Update(const G4NuclearLevelManager* manager,
G4int Z, G4int A, G4double exc);
private:
G4double E1Pdf(G4double energy);
G4double GammaTime();
G4int nucleusA;
G4int nucleusZ;
G4int nBins;
G4int verbose;
G4double eMin;
G4double eMax;
G4double minLevelE;
G4double excitation;
G4double eGamma;
G4double gammaCreationTime;
G4double energyGDR2;
G4double widthGDR;
G4double widthGDR2;
std::vector<G4double> sampleArray;
const G4NuclearLevelManager* levelManager;
G4Pow* g4pow;
G4ConstantLevelDensityParameter ldPar;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4DiscreteGammaDeexcitation.hh
-100
View File
@@ -1,100 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DiscreteGammaDeexcitation.hh 85841 2014-11-05 15:35:06Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 8 March 2001, Fan Lei (flei@space.qinetiq.com)
// added the following as part if the IC implementation
// void SetICM(G4bool hl) { _icm = hl; };
// void SetRDM(G4bool hl) { _rdm = hl; };
// void SetHL(G4double hl) { _max_hl = hl; };
// private:
// G4double _max_hl;
// G4bool _icm;
// G4bool _rdm;
//
//
// -------------------------------------------------------------------
//
#ifndef G4DiscreteGammaDeexcitation_hh
#define G4DiscreteGammaDeexcitation_hh
#include "G4VGammaDeexcitation.hh"
#include "globals.hh"
#include "G4DiscreteGammaTransition.hh"
#include "G4Fragment.hh"
class G4NuclearLevelManager;
class G4NuclearLevelStore;
class G4DiscreteGammaTransition;
class G4DiscreteGammaDeexcitation : public G4VGammaDeexcitation {
public:
G4DiscreteGammaDeexcitation();
virtual ~G4DiscreteGammaDeexcitation();
virtual G4bool CanDoTransition(G4Fragment* nucleus);
inline void SetICM(G4bool hl) { icm = hl; };
inline void SetRDM(G4bool hl) { rdm = hl; };
inline void SetHL(G4double hl) { maxhl = hl; };
private:
G4int nucleusZ;
G4int nucleusA;
G4double maxhl;
G4bool icm;
G4bool rdm;
G4NuclearLevelStore* store;
G4NuclearLevelManager* levelManager;
G4DiscreteGammaTransition* dtransition;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4DiscreteGammaTransition.hh
-122
View File
@@ -1,122 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DiscreteGammaTransition.hh 85841 2014-11-05 15:35:06Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaTransition
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 8 March 2002, Fan Lei (flei@space.qinetiq.com)
// added
// 1) SetRDM () to switch on/off IC process
// 2) GetOrbitNumber () to return the CE oribit number
// 3) GetBondEnergy() for the converted e-
// 4) IsaGamma() to separate CE from gamma
//
// 21 Nov. 2001, Fan Lei (flei@space.qinetiq.com)
// i) added G4int _nucleusZ initialise it through the constructor
// ii) modified SelectGamma() to allow the generation of conversion electrons
// iii) added #include G4AtomicShells.hh
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
//
//
// 19 April 2010, J. M. Quesada.
// Corrections added for taking into account mismatch between tabulated
// gamma energies and level energy differences (fake photons eliminated)
//
// 6 October 2010, M. Kelsey
// Store NuclearLevel as const-reference, not as copied value.
//
// 5 May 2011, V.Ivanchenko removed unused constructor
//
// -------------------------------------------------------------------
#ifndef G4DiscreteGammaTransition_hh
#define G4DiscreteGammaTransition_hh
#include "globals.hh"
#include "G4VGammaTransition.hh"
class G4NuclearLevel;
class G4NuclearLevelManager;
class G4DiscreteGammaTransition : public G4VGammaTransition
{
public:
G4DiscreteGammaTransition(const G4NuclearLevel* level,
G4int Z, G4int ver);
virtual ~G4DiscreteGammaTransition();
virtual void SetEnergyFrom(G4double energy);
virtual G4double GetGammaEnergy();
virtual G4double GetGammaCreationTime();
virtual void SelectGamma();
inline void SetICM(G4bool ic) { icm = ic; };
inline G4bool GetICM() const { return icm;};
inline G4double GetBondEnergy () { return bondE;};
inline G4int GetOrbitNumber () { return orbitE;};
inline G4bool IsAGamma() { return aGamma;};
inline void Update(const G4NuclearLevel* level, G4int Z)
{
aLevel = level;
nucleusZ = Z;
}
private:
G4int nucleusZ;
G4int orbitE;
G4int verbose;
G4double bondE;
G4double gammaEnergy;
G4double excitation;
G4double gammaCreationTime;
G4bool aGamma;
G4bool icm;
const G4NuclearLevel* aLevel;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4E1Probability.hh
-84
View File
@@ -1,84 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4E1Probability.hh 88709 2015-03-06 15:33:12Z gcosmo $
//
//---------------------------------------------------------------------
//
// Geant4 header G4E1Probability
//
// by V. Lara (May 2003)
//
// Modifications:
// 18.05.2010 V.Ivanchenko trying to speedup the most slow method
// by usage of G4Pow, integer A and introduction of const members
//
//
#ifndef G4E1Probability_hh
#define G4E1Probability_hh
#include "globals.hh"
#include "G4VEmissionProbability.hh"
#include "G4Fragment.hh"
class G4Pow;
class G4E1Probability : public G4VEmissionProbability
{
public:
G4E1Probability();
virtual ~G4E1Probability();
G4double EmissionProbability(const G4Fragment& frag, G4double excite);
G4double EmissionProbDensity(const G4Fragment& frag, G4double ePhoton);
private:
G4E1Probability(const G4E1Probability& right);
const G4E1Probability& operator=(const G4E1Probability& right);
G4bool operator==(const G4E1Probability& right) const;
G4bool operator!=(const G4E1Probability& right) const;
// Integrator (simple Gaussian quadrature)
G4double EmissionIntegration(const G4Fragment& frag,
G4double lowLim, G4double upLim);
// members
G4Pow* fG4pow;
G4double theLevelDensityPerNucleon;
G4double normC;
G4double aLevelDensityParam;
G4double sigma0;
G4double Egdp;
G4double GammaR;
G4int Afrag;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevel.hh
-177
View File
@@ -1,177 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevel.hh 86986 2014-11-21 13:00:05Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevel
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
// 06 Oct 2010, M. Kelsey (kelsey@slac.stanford.edu)
// Add friendship for G4NuclearLevelManager; define private
// constructors without vectors.
//
// 21 Nov. 2001, Fan Lei (flei@space.qinetiq.com)
// Added K->N+ internal conversion coefficiencies and their access
// functions
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added half-life, angular momentum, parity, emissioni type
// reading from experimental data.
//
// 28 October 2010, V.Ivanchenko moved copy constructor to source, cleanup
//
//
// -------------------------------------------------------------------
#ifndef G4NUCLEARLEVEL_HH
#define G4NUCLEARLEVEL_HH 1
#include "globals.hh"
#include <vector>
class G4NuclearLevel
{
public:
G4NuclearLevel(G4double energy, G4double halfLife,
G4double angularMomentum, const std::vector<G4double>& eGamma,
const std::vector<G4double>& wGamma, const std::vector<G4double>& polarities,
const std::vector<G4double>& kCC, const std::vector<G4double>& l1CC,
const std::vector<G4double>& l2CC, const std::vector<G4double>& l3CC,
const std::vector<G4double>& m1CC, const std::vector<G4double>& m2CC,
const std::vector<G4double>& m3CC, const std::vector<G4double>& m4CC,
const std::vector<G4double>& m5CC, const std::vector<G4double>& nPlusCC,
const std::vector<G4double>& totalCC);
~G4NuclearLevel();
const std::vector<G4double>& GammaEnergies() const;
const std::vector<G4double>& GammaWeights() const;
const std::vector<G4double>& GammaProbabilities() const;
const std::vector<G4double>& GammaCumulativeProbabilities() const;
const std::vector<G4double>& GammaPolarities() const;
const std::vector<G4double>& KConvertionProbabilities() const;
const std::vector<G4double>& L1ConvertionProbabilities() const;
const std::vector<G4double>& L2ConvertionProbabilities() const;
const std::vector<G4double>& L3ConvertionProbabilities() const;
const std::vector<G4double>& M1ConvertionProbabilities() const;
const std::vector<G4double>& M2ConvertionProbabilities() const;
const std::vector<G4double>& M3ConvertionProbabilities() const;
const std::vector<G4double>& M4ConvertionProbabilities() const;
const std::vector<G4double>& M5ConvertionProbabilities() const;
const std::vector<G4double>& NPlusConvertionProbabilities() const;
const std::vector<G4double>& TotalConvertionProbabilities() const;
G4double Energy() const;
G4double AngularMomentum() const;
G4double HalfLife() const;
G4int NumberOfGammas() const;
void PrintAll() const;
void PrintLevels() const;
G4bool operator==(const G4NuclearLevel &right) const;
G4bool operator!=(const G4NuclearLevel &right) const;
G4bool operator<(const G4NuclearLevel &right) const;
G4NuclearLevel& operator=(const G4NuclearLevel &right);
G4NuclearLevel(const G4NuclearLevel &right);
private:
friend class G4NuclearLevelManager;
G4NuclearLevel();
G4NuclearLevel(G4double energy, G4double halfLife,
G4double angularMomentum);
void Finalize();
void MakeProbabilities();
void MakeCumProb();
G4int Increment(G4int aF);
std::vector<G4double> _energies;
std::vector<G4double> _weights;
std::vector<G4double> _prob;
std::vector<G4double> _cumProb;
std::vector<G4double> _polarities;
std::vector<G4double> _kCC;
std::vector<G4double> _l1CC;
std::vector<G4double> _l2CC;
std::vector<G4double> _l3CC;
std::vector<G4double> _m1CC;
std::vector<G4double> _m2CC;
std::vector<G4double> _m3CC;
std::vector<G4double> _m4CC;
std::vector<G4double> _m5CC;
std::vector<G4double> _nPlusCC;
std::vector<G4double> _totalCC;
G4double _energy;
G4double _halfLife;
G4double _angularMomentum;
G4int _nGammas;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevelManager.hh
-140
View File
@@ -1,140 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevelManager.hh 87163 2014-11-26 08:46:54Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevelManager
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
// 21 Nov. 2001, Fan Lei (flei@space.qinetiq.com)
// Added K->N+ internal conversion coefficiencies and their access
// functions
//
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added half-life, angular momentum, parity, emissioni type
// reading from experimental data.
// 02 May 2003, Vladimir Ivanchenko remove rublic copy contructor
// 06 Oct 2010, M. Kelsey -- Use object storage, not pointers, drop
// public access to list
// -------------------------------------------------------------------
#ifndef G4NUCLEARLEVELMANAGER_HH
#define G4NUCLEARLEVELMANAGER_HH 1
#include <iosfwd>
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4PtrLevelVector.hh"
class G4NuclearLevel;
class G4NuclearLevelManager
{
public:
G4NuclearLevelManager(G4int Z, G4int A, const G4String& filename);
G4NuclearLevelManager(const G4NuclearLevelManager & right);
~G4NuclearLevelManager();
void SetNucleus(G4int Z, G4int A, const G4String& filename);
inline G4bool IsValid() const { return _validity; }
inline G4int NumberOfLevels() const { return (_levels ? _levels->size() : 0); }
const G4NuclearLevel* GetLevel(G4int i) const;
const G4NuclearLevel* NearestLevel(G4double energy,
G4double eDiffMax=1.e+8) const;
const G4NuclearLevel* LowestLevel() const;
const G4NuclearLevel* HighestLevel() const;
G4double MinLevelEnergy() const;
G4double MaxLevelEnergy() const;
void PrintLevels();
void PrintAll();
private:
const G4NuclearLevelManager& operator=(const G4NuclearLevelManager &right);
G4bool operator==(const G4NuclearLevelManager &right) const;
G4bool operator!=(const G4NuclearLevelManager &right) const;
G4bool Read(std::ifstream& aDataFile);
G4bool ReadDataLine(std::ifstream& dataFile);
G4bool ReadDataItem(std::istream& dataFile, G4double& x);
void ProcessDataLine();
void MakeLevels(const G4String& filename);
void ClearLevels();
G4NuclearLevel* UseLevelOrMakeNew(G4NuclearLevel* level);
void AddDataToLevel(G4NuclearLevel* level);
void FinishLevel(G4NuclearLevel* level);
G4int _nucleusA;
G4int _nucleusZ;
//G4String _fileName;
G4bool _validity;
G4PtrLevelVector* _levels;
// Buffers for reading data file
//char buffer[30]; // For doubles in scientific notation
static G4double _levelEnergy;
static G4double _gammaEnergy;
static G4double _probability;
static G4double _polarity;
static G4double _halfLife;
static G4double _angularMomentum;
static G4double _kCC;
static G4double _l1CC;
static G4double _l2CC;
static G4double _l3CC;
static G4double _m1CC;
static G4double _m2CC;
static G4double _m3CC;
static G4double _m4CC;
static G4double _m5CC;
static G4double _nPlusCC;
static G4double _totalCC;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevelStore.hh
-94
View File
@@ -1,94 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevelStore.hh 88406 2015-02-18 09:13:29Z gcosmo $
//
// 04-10-2010 M. Kelsey -- Replace G4String keys with integers (ZZZAAA),
// move string operation to GenerateFilename()
// 17-11-2010 V. Ivanchenko - make as a classical singleton.
//
// 17-10-2011 L. Desorgher -- Allow the user to replace the radioactive
// decay data provided in Geant4 by its own data file for
// a given isotope
// 06-01-2012 V. Ivanchenko - added nuclear level data structure for
// usage in HEP where internal conversion is neglected;
// cleanup the code; new method GetLevelManager
// 19-11-2014 M. Asai - protection against reading the same file from
// more than one worker threads
#ifndef G4NuclearLevelStore_hh
#define G4NuclearLevelStore_hh 1
#include "G4NuclearLevelManager.hh"
#include "G4ThreadLocalSingleton.hh"
#include "globals.hh"
#include <map>
class G4NuclearLevelStore
{
friend class G4ThreadLocalSingleton<G4NuclearLevelStore>;
private:
G4NuclearLevelStore();
public:
static G4NuclearLevelStore* GetInstance();
G4NuclearLevelManager* GetManager(G4int Z, G4int A);
~G4NuclearLevelStore();
void AddUserEvaporationDataFile(G4int Z, G4int A,
const G4String& filename);
private:
G4int GenerateKey(G4int Z, G4int A) const { return Z*1000+A; }
G4String GenerateFileName(G4int Z, G4int A) const;
typedef std::map<G4int,G4NuclearLevelManager*> ManagersMap;
ManagersMap theManagers;
G4String dirName;
static G4ThreadLocal G4NuclearLevelStore* theInstance;
#ifdef G4MULTITHREADED
static G4NuclearLevelStore* theShadowInstance;
#endif
G4bool userFiles;
std::map<G4int, G4String> theUserDataFiles;
#ifdef G4MULTITHREADED
public:
static G4Mutex nuclearLevelStoreMutex;
#endif
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4PhotonEvaporationOLD.hh
-145
View File
@@ -1,145 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PhotonEvaporationOLD.hh 89158 2015-03-21 19:15:25Z vnivanch $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4PhotonEvaporationOLD
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
//Modifications:
//
// 18 October 2002, Fan Lei (flei@space.qinetiq.com)
//
// Implementation of Internal Convertion process in discrete deexcitation
// The following public methods have been added.
//
// void SetICM (G4bool);
// void RDMForced(G4bool);
// void SetMaxHalfLife(G4double) ;
// void SetEOccupancy( G4ElectronOccupancy eOccupancy) ;
// G4ElectronOccupancy GetEOccupancy () ;
// G4int GetVacantShellNumber () { return _vShellNumber;};
//
// and the following priivate menbers
//
// G4ElectronOccupancy _eOccupancy;
// G4int _vShellNumber;
//
// 11 May 2010, V.Ivanchenko added EmittedFragment and BreakUpFragment
// methods
//
// 22 October 2015, V.Ivanchenko renamed to G4PhotonEvaporationOLD
//
// -------------------------------------------------------------------
#ifndef G4PHOTONEVAPORATIONOLD_HH
#define G4PHOTONEVAPORATIONOLD_HH 1
#include "globals.hh"
#include "G4VEvaporationChannel.hh"
#include "G4VEmissionProbability.hh"
#include "G4VGammaDeexcitation.hh"
#include "G4ElectronOccupancy.hh"
class G4Fragment;
class G4PhotonEvaporationOLD : public G4VEvaporationChannel {
public:
G4PhotonEvaporationOLD(const G4String & aName = "");
virtual ~G4PhotonEvaporationOLD();
// returns one gamma or e-
virtual G4Fragment* EmittedFragment(G4Fragment* theNucleus);
// returns "false", emitted gamma and e- are added to the results
virtual G4bool
BreakUpChain(G4FragmentVector* theResult, G4Fragment* theNucleus);
// emitted gamma and e- are added to the results
virtual G4FragmentVector* BreakUpFragment(G4Fragment* theNucleus);
// emitted gamma, e-, and residual fragment are added to the results
virtual G4FragmentVector * BreakItUp(const G4Fragment & nucleus);
// emitted gamma, e-, and residual fragment are added to the results
virtual G4FragmentVector * BreakUp(const G4Fragment & nucleus);
virtual G4double GetEmissionProbability(G4Fragment* theNucleus);
virtual void SetEmissionStrategy(G4VEmissionProbability * probAlgorithm);
void SetVerboseLevel(G4int verbose);
virtual void SetICM (G4bool);
virtual void RDMForced (G4bool);
void SetMaxHalfLife(G4double);
void SetTimeLimit(G4double value);
void SetEOccupancy( G4ElectronOccupancy eOccupancy) ;
inline G4ElectronOccupancy GetEOccupancy () { return eOccupancy;} ;
inline G4int GetVacantShellNumber () { return vShellNumber;};
private:
G4int verbose;
G4bool myOwnProbAlgorithm;
G4VEmissionProbability * probAlgorithm;
G4VGammaDeexcitation * discrDeexcitation;
G4VGammaDeexcitation * contDeexcitation;
G4ElectronOccupancy eOccupancy;
G4int vShellNumber;
G4Fragment* nucleus;
G4double gammaE;
G4PhotonEvaporationOLD(const G4PhotonEvaporationOLD & right);
const G4PhotonEvaporationOLD & operator = (const G4PhotonEvaporationOLD & right);
G4bool operator == (const G4PhotonEvaporationOLD & right) const;
G4bool operator != (const G4PhotonEvaporationOLD & right) const;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4PtrLevelVector.hh
-53
View File
@@ -1,53 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PtrLevelVector.hh 67983 2013-03-13 10:42:03Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4PtrLevelVector
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 25 October 1998
//
// Modifications:
//
// -------------------------------------------------------------------
#ifndef G4PTRLEVELVECTOR_HH
#define G4PTRLEVELVECTOR_HH 1
#include "G4NuclearLevel.hh"
#include <vector>
typedef std::vector<G4NuclearLevel *> G4PtrLevelVector;
struct DeleteLevel { void operator () (G4NuclearLevel * aL) {delete aL;} };
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4VGammaDeexcitation.hh
-124
View File
@@ -1,124 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VGammaDeexcitation.hh 88191 2015-02-02 17:27:37Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4VGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
//
// 21 Nov 2001, Fan Lei (flei@space.qinetiq.com)
// Modified GenerateGamma() and UpdateUncleus() for implementation
// of Internal Conversion processs
//
// 8 March 2002, Fan Lei (flei@space.qinetiq.com)
// Added SetEO () , GetEO(), UpdateElectrons() to allow the assignment
// and modification of electron configuration.
//
// 18 October 2002, F. Lei
// Added GetVaccantSN() and _vSN in order to link to ARM in low-e em
// _vSN is updated in UpdateElectron()
// Added SetVaccantSN(). It is need to to re-set _vSN after each
// IC happened.
//
// 28 April 2010, V.Ivanchenko cleanup methods
//
// -------------------------------------------------------------------
//
#ifndef G4VGAMMADEEXCITATION_HH
#define G4VGAMMADEEXCITATION_HH 1
#include "globals.hh"
#include "G4VGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4FragmentVector.hh"
#include "G4ElectronOccupancy.hh"
class G4VGammaDeexcitation {
public:
G4VGammaDeexcitation();
virtual ~G4VGammaDeexcitation();
virtual G4bool CanDoTransition(G4Fragment* aNucleus) = 0;
// Chain of gamma transitions
void DoChain(G4FragmentVector*, G4Fragment* nucleus);
G4Fragment * GenerateGamma(G4Fragment* nucleus);
inline void SetVerboseLevel(G4int verbose){ _verbose = verbose; };
//inline void Initialise();
inline void SetEO(G4ElectronOccupancy eo) { _electronO = eo; };
inline void SetVaccantSN( G4int val ) { _vSN = val;};
inline G4ElectronOccupancy GetEO() { return _electronO; };
inline G4int GetVacantSN() { return _vSN;};
inline void SetTimeLimit(G4double value) { _timeLimit = value; }
protected:
G4VGammaTransition* _transition;
G4int _verbose;
G4double _tolerance;
G4double _timeLimit;
private:
G4VGammaDeexcitation(const G4VGammaDeexcitation & right);
const G4VGammaDeexcitation & operator = (const G4VGammaDeexcitation & right);
G4bool operator == (const G4VGammaDeexcitation & right) const;
G4bool operator != (const G4VGammaDeexcitation & right) const;
G4ElectronOccupancy _electronO;
G4int _vSN;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4ContinuumGammaDeexcitation.cc
-122
View File
@@ -1,122 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuumGammaDeexcitation.cc 87585 2014-12-11 14:22:21Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaDeexcitation
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 02 May 2003, Vladimir Ivanchenko change interface to G4NuclearlevelManager
//
// 19 April 2010 J. M. Quesada: smaller value of tolerance parameter
//
// -------------------------------------------------------------------
//
// Class G4ContinuumGammaDeexcitation.cc
//
// Concrete class derived from G4VGammaDeexcitation
//
//
#include "G4ContinuumGammaDeexcitation.hh"
#include "G4Gamma.hh"
#include "G4ContinuumGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
#include "G4NuclearLevelStore.hh"
#include "G4Fragment.hh"
#include "G4ConstantLevelDensityParameter.hh"
G4ContinuumGammaDeexcitation::G4ContinuumGammaDeexcitation()
: nucleusZ(0), nucleusA(0), levelManager(0), ctransition(0)
{
store = G4NuclearLevelStore::GetInstance();
}
G4ContinuumGammaDeexcitation::~G4ContinuumGammaDeexcitation()
{}
G4bool G4ContinuumGammaDeexcitation::CanDoTransition(G4Fragment* nucleus)
{
G4int Z = nucleus->GetZ_asInt();
G4int A = nucleus->GetA_asInt();
G4double excitation = nucleus->GetExcitationEnergy();
if (excitation <= _tolerance) {
if (_verbose > 1) {
G4cout << "G4ContinuumGammaDeexcitation::CanDoTransition fails; Z= " << Z
<< " A= " << A << " Eex(meV)= " << excitation << G4endl;
}
return false;
}
if (nucleusA != A || nucleusZ != Z) {
levelManager = store->GetManager(Z,A);
nucleusA = A;
nucleusZ = Z;
}
if (_verbose > 1) {
G4cout << "G4ContinuumGammaDeexcitation: "
<< " Z= " << Z << " A= " << A << " Eex= " << excitation
<< G4endl;
}
if (levelManager && excitation <= levelManager->MaxLevelEnergy() + _tolerance) {
if (_verbose > 0) {
G4cout << "G4ContinuumGammaDeexcitation::CanDoTransition - Excitation "
<< excitation << " below max discrete level "
<< levelManager->MaxLevelEnergy() << G4endl;
}
return false;
}
if(!ctransition) {
ctransition =
new G4ContinuumGammaTransition(levelManager,Z,A,excitation,_verbose);
_transition = ctransition;
} else {
ctransition->Update(levelManager,Z,A,excitation);
}
/*
G4cout <<"G4ContinuumGammaDeexcitation::CanDoTransition: "
<< " Eex(MeV)= " << excitation
<< " Emax(MeV)= " << levelManager->MaxLevelEnergy()
<< " Z= " << Z << " A= " << A << G4endl;
*/
return true;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4ContinuumGammaTransition.cc
-244
View File
@@ -1,244 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuumGammaTransition.cc 91886 2015-08-10 07:08:25Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4ContinuumGammaTransition
//
// Authors: Carlo Dallapiccola (dallapiccola@umdhep.umd.edu)
// Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
// 02 May 2003, V. Ivanchenko change interface to G4NuclearlevelManager
// 06 Oct 2010, M. Kelsey -- follow changes to G4NuclearLevelManager
// 17 Nov 2010, V. Ivanchenko use exponential law for sampling of time
// and extra cleanup
// ----------------------------------------------------------------------------
//
// Class G4ContinuumGammaTransition.cc
//
#include "G4ContinuumGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4Pow.hh"
#include "G4Log.hh"
//static const G4double normC = CLHEP::millibarn/
// (CLHEP::pi*CLHEP::hbarc*CLHEP::pi*CLHEP::hbarc);
static const G4double factor = 5;
static const G4double tolerance = 0.1*CLHEP::keV;
G4ContinuumGammaTransition::G4ContinuumGammaTransition(
const G4NuclearLevelManager* manager,
G4int Z, G4int A, G4double exc, G4int verb)
{
nBins = 100;
verbose = verb;
eMin = keV;
eMax = minLevelE = eGamma = gammaCreationTime = 0.0;
sampleArray.resize(nBins+1,0.0);
g4pow = G4Pow::GetInstance();
Update(manager, Z, A, exc);
}
G4ContinuumGammaTransition::~G4ContinuumGammaTransition()
{}
void G4ContinuumGammaTransition::Update(const G4NuclearLevelManager* manager,
G4int Z, G4int A, G4double exc)
{
levelManager = manager;
nucleusZ = Z;
nucleusA = A;
excitation = exc;
eGamma = 0.;
gammaCreationTime = 0.;
minLevelE = DBL_MAX;
if(levelManager) {
minLevelE = std::max(0.5*levelManager->MinLevelEnergy(), tolerance);
}
// Energy range for photon generation;
// upper limit is defined 5*Gamma(GDR) from GDR peak
// Giant Dipole Resonance energy
G4double energyGDR = (40.3 / g4pow->powZ(nucleusA,0.2) ) * MeV;
energyGDR2 = energyGDR*energyGDR;
// Giant Dipole Resonance width
widthGDR = 0.30 * energyGDR;
widthGDR2 = widthGDR*widthGDR;
// Extend
eMax = energyGDR + factor * widthGDR;
if (eMax > excitation) { eMax = excitation; }
}
void G4ContinuumGammaTransition::SelectGamma()
{
eGamma = 0.;
sampleArray[0] = 0.0;
G4int i;
G4double del = (eMax - eMin) / G4double(nBins);
G4double sum = 0;
G4double w1 = E1Pdf(eMin);
G4double w2;
//G4cout << eMin << " " << eMax << " " << del << G4endl;
for (i=1; i<=nBins; i++) {
G4double e = eMin + del * i;
w2 = E1Pdf(e);
sum += 0.5*(w1 + w2);
w1 = w2;
sampleArray[i] = sum;
if(verbose > 1) {
G4cout << "*---* G4ContinuumTransition: e = " << e
<< " pdf = " << sampleArray[i] << G4endl;
}
}
sum *= G4UniformRand();
eGamma = eMax;
for (i=1; i<=nBins; i++) {
if(sum <= sampleArray[i]) {
eGamma = eMin + del * i;
G4double w = sampleArray[i] - sampleArray[i-1];
//G4cout << eGamma << " " << w << G4endl;
if(w != 0.0) {
eGamma -= (sampleArray[i] - sum)*del/w;
}
break;
}
}
G4double finalExcitation = excitation - eGamma;
if(verbose > 1) {
G4cout << "*---*---* G4ContinuumTransition: eGamma = " << eGamma
<< " finalExcitation = " << finalExcitation << G4endl;
}
if(finalExcitation <= minLevelE) {
eGamma = excitation;
} else {
finalExcitation = levelManager->NearestLevel(finalExcitation)->Energy();
eGamma = excitation - finalExcitation;
}
gammaCreationTime = GammaTime();
if(verbose > 1) {
G4cout << "*---*---* G4ContinuumTransition: gammaCreationTime = "
<< gammaCreationTime/second << G4endl;
}
}
G4double G4ContinuumGammaTransition::GetGammaEnergy()
{
return eGamma;
}
G4double G4ContinuumGammaTransition::GetGammaCreationTime()
{
return gammaCreationTime;
}
void G4ContinuumGammaTransition::SetEnergyFrom(G4double energy)
{
excitation = energy;
}
G4double G4ContinuumGammaTransition::E1Pdf(G4double e)
{
G4double theProb = 0.0;
G4double U = excitation - e;
if(U < 0.0) { return theProb; }
G4double aLevelDensityParam =
ldPar.LevelDensityParameter(nucleusA,nucleusZ,excitation);
//G4double levelDensBef = G4Exp(2.0*std::sqrt(aLevelDensityParam*excitation));
//G4double levelDensAft = G4Exp(2.0*std::sqrt(aLevelDensityParam*(excitation - e)));
G4double coeff = G4Exp(2.0*(std::sqrt(aLevelDensityParam*U)
- std::sqrt(aLevelDensityParam*excitation)));
//if(verbose > 20)
// G4cout << nucleusA << " LevelDensityParameter = " << aLevelDensityParam
// << " Bef Aft " << levelDensBef << " " << levelDensAft << G4endl;
// Now form the probability density
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
G4double sigma0 = 2.5 * nucleusA;
G4double e2 = e*e;
G4double numerator = sigma0 * e2 * widthGDR2;
G4double denominator = (e2 - energyGDR2)* (e2 - energyGDR2) + widthGDR2*e2;
// if (denominator < 1.0e-9) denominator = 1.0e-9;
G4double sigmaAbs = numerator/denominator;
if(verbose > 2) {
G4cout << "E_GDR(MeV)= " << std::sqrt(energyGDR2) << " W_GDR(MeV)= " << widthGDR
<< " sigAbs= " << sigmaAbs
<< " E(MeV)= " << e << " coeff= " << coeff
<< G4endl;
}
theProb = sigmaAbs * e2 * coeff;
return theProb;
}
G4double G4ContinuumGammaTransition::GammaTime()
{
G4double tau = hbar_Planck/widthGDR;
G4double creationTime = -tau*G4Log(G4UniformRand());
return creationTime;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4DiscreteGammaDeexcitation.cc
-135
View File
@@ -1,135 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DiscreteGammaDeexcitation.cc 88191 2015-02-02 17:27:37Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
// 8 March 2001, Fan Lei (flei@space.qinetiq.com)
// Added the following as part if the IC implementation
// void SetICM(G4bool hl) { _icm = hl; };
// void SetRDM(G4bool hl) { _rdm = hl; };
// void SetHL(G4double hl) { _max_hl = hl; };
// Changed in CreateTransition() from
// return new G4DiscreteGammaTransition(*level);
// To
// return new G4DiscreteGammaTransition(*level,Z);
// Added in CanDoTransition
// if (level->HalfLife() > _max_hl && !_rdm ) canDo = false;
//
// 3 November 2011 L. Desorgher
// remove the Z<= 98 limit
//
// -------------------------------------------------------------------
#include "G4DiscreteGammaDeexcitation.hh"
#include "G4DiscreteGammaTransition.hh"
#include "G4NuclearLevelManager.hh"
#include "G4NuclearLevelStore.hh"
#include "G4SystemOfUnits.hh"
G4DiscreteGammaDeexcitation::G4DiscreteGammaDeexcitation():
nucleusZ(0), nucleusA(0), maxhl(1e-6*CLHEP::second), icm(false),
rdm(false), levelManager(0), dtransition(0)
{
store = G4NuclearLevelStore::GetInstance();
}
G4DiscreteGammaDeexcitation::~G4DiscreteGammaDeexcitation()
{}
G4bool G4DiscreteGammaDeexcitation::CanDoTransition(G4Fragment* nucleus)
{
G4int Z = nucleus->GetZ_asInt();
G4int A = nucleus->GetA_asInt();
G4double excitation = nucleus->GetExcitationEnergy();
if(excitation <= _tolerance) {
if (_verbose > 1) {
G4cout << "G4DiscreteGammaDeexcitation::CanDoTransition fails; Z= " << Z
<< " A= " << A << " Eex(meV)= " << excitation/MeV << G4endl;
}
return false;
}
if (nucleusA != A || nucleusZ != Z) {
levelManager = store->GetManager(Z,A);
nucleusA = A;
nucleusZ = Z;
}
if(!levelManager ||
excitation > levelManager->MaxLevelEnergy() + _tolerance) { return false; }
if (_verbose > 1) {
G4cout << "G4DiscreteGammaDeexcitation::CanDoTransition "
<< " Z= " << Z << " A= " << A << " Eex= " << excitation
<< G4endl;
}
const G4NuclearLevel* level = levelManager->NearestLevel(excitation);
// long lived level
if (!level || level->HalfLife() > maxhl) { return false; }
// if (!level || (level->HalfLife() > maxhl && !rdm) ) { return false; }
if (_verbose > 1) {
G4cout << "G4DiscreteGammaDeexcitation: Elevel(MeV)= "
<< level->Energy()/MeV << ", Eex(MeV)= " << excitation << G4endl;
}
if(!_transition) {
dtransition = new G4DiscreteGammaTransition(level,Z,_verbose);
dtransition->SetICM(icm);
_transition = dtransition;
} else {
dtransition->Update(level,Z);
}
// control on ICM
if(level->HalfLife() > _timeLimit) {
dtransition->SetICM(true);
} else {
dtransition->SetICM(icm);
}
dtransition->SetEnergyFrom(excitation);
if (_verbose > 1) {
G4cout << "CanDoTransition done: Eex(MeV)= "
<< excitation/MeV << ", level enrgies: Emin(MeV)= "
<< levelManager->MinLevelEnergy()/MeV << " Emax(MeV)= "
<< levelManager->MaxLevelEnergy()/MeV << G4endl;
}
return true;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4DiscreteGammaTransition.cc
-255
View File
@@ -1,255 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DiscreteGammaTransition.cc 91886 2015-08-10 07:08:25Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4DiscreteGammaTransition
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
//
// 21 Nov. 2001, Fan Lei (flei@space.qinetiq.com)
// i) added G4int _nucleusZ initialise it through the constructor
// ii) modified SelectGamma() to allow the generation of
// conversion e-
// iii) added #include G4AtomicShells.hh
//
// 09 Sep. 2002, Fan Lei (flei@space.qinetiq.com)
// Added renormalization to determine whether transition leads to
// electron or gamma in SelectGamma()
//
// 19 April 2010, J. M. Quesada.
// Corrections added for taking into account mismatch between
// tabulated gamma energies and level energy differences
// (fake photons eliminated)
//
// 9 May 2010, V.Ivanchenko
// Removed unphysical corretions of gamma energy; fixed default
// particle as gamma; do not subtract bounding energy in case of
// electron emmision
//
// 3 November 2011, L. Desorgher
// Extend the use of the code for Z>100 by not calling
// G4AtomicShells::GetBindingEnergy for Z>100
// For Z>100 the binding energy is set to 0 and atomic
// relaxation is not simulated in G4RadDecay
//
// -------------------------------------------------------------------
#include "G4DiscreteGammaTransition.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4AtomicShells.hh"
#include "G4NuclearLevel.hh"
#include "G4NuclearLevelStore.hh"
#include "G4Pow.hh"
#include "G4Log.hh"
static const G4double tolerance = 0.1*CLHEP::keV;
G4DiscreteGammaTransition::G4DiscreteGammaTransition(
const G4NuclearLevel* level, G4int Z, G4int verb)
: orbitE(-1), bondE(0.), gammaEnergy(0.), excitation(0.),
gammaCreationTime(0.), aGamma(true), icm(false)
{
verbose = verb;
Update(level, Z);
}
G4DiscreteGammaTransition::~G4DiscreteGammaTransition()
{}
void G4DiscreteGammaTransition::SelectGamma()
{
// default gamma
aGamma = true;
gammaEnergy = 0.;
G4int nGammas = aLevel->NumberOfGammas();
if (nGammas > 0) {
G4int iGamma = 0;
if(1 < nGammas) {
G4double random = G4UniformRand();
//G4cout << "G4DiscreteGammaTransition::SelectGamma N= "
// << nGammas << " rand= " << random << G4endl;
for(iGamma=0; iGamma<nGammas; ++iGamma) {
//G4cout << iGamma << " prob= "
// << (aLevel->GammaCumulativeProbabilities())[iGamma] << G4endl;
if(random <= (aLevel->GammaCumulativeProbabilities())[iGamma])
{ break; }
}
}
/*
G4cout << "Elevel(MeV)= " << aLevel->Energy()
<< " Etran(MeV)= " << (aLevel->GammaEnergies())[iGamma]
<< " Eexc(MeV)= " << excitation << G4endl;
*/
// VI 2014: initial excitation energy may be not exactly energy of the level
// final excitation energy is always energy of some level or zero
// transition to the ground state should be always equal to
// the excitation energy
gammaEnergy = (aLevel->GammaEnergies())[iGamma]
+ excitation - aLevel->Energy();
// this check is needed to remove cases when nucleaus is left in
// slightly excited state which will require very low energy
// gamma emission
if(excitation <= gammaEnergy + tolerance) { gammaEnergy = excitation; }
//JMQ:
//1)If chosen gamma energy is close enough to excitation energy,
// the later is used instead for gamma dacey to gs (it guarantees
// energy conservation)
//2)For energy conservation, level energy differences instead of
// tabulated gamma energies must be used (origin of final fake photons)
// VI: remove fake photons - applied only for the last transition
// do not applied on each transition
//if(std::fabs(excitation - gammaEnergy) < tolerance) {
// gammaEnergy = excitation;
//}
// JMQ: Warning: the following check is needed to avoid loops:
// Due essentially to missing nuclear levels in data files, it is
// possible that gammaEnergy is so low as the nucleus doesn't change
// its level after the transition.
// When such case is found, force the full deexcitation of the nucleus.
//
// NOTE: you should force the transition to the next lower level,
// but this change needs a more complex revision of actual
// design.
// I leave this for a later revision.
// VI: the check is needed to remove very low-energy gamma
if (gammaEnergy <= tolerance) { gammaEnergy = excitation; }
/*
G4cout << "G4DiscreteGammaTransition::SelectGamma: " << gammaEnergy
<< " Eexc= " << excitation
<< " icm: " << icm << G4endl;
*/
// now decide whether Internal Coversion electron should be emitted instead
if (icm) {
G4double random = G4UniformRand();
if ( random <= (aLevel->TotalConvertionProbabilities())[iGamma]
*(aLevel->GammaWeights())[iGamma]
/((aLevel->TotalConvertionProbabilities())[iGamma]
*(aLevel->GammaWeights())[iGamma]
+(aLevel->GammaWeights())[iGamma]))
{
G4int iShell = 9;
random = G4UniformRand() ;
if ( random <= (aLevel->KConvertionProbabilities())[iGamma])
{ iShell = 0;}
else if ( random <= (aLevel->L1ConvertionProbabilities())[iGamma])
{ iShell = 1;}
else if ( random <= (aLevel->L2ConvertionProbabilities())[iGamma])
{ iShell = 2;}
else if ( random <= (aLevel->L3ConvertionProbabilities())[iGamma])
{ iShell = 3;}
else if ( random <= (aLevel->M1ConvertionProbabilities())[iGamma])
{ iShell = 4;}
else if ( random <= (aLevel->M2ConvertionProbabilities())[iGamma])
{ iShell = 5;}
else if ( random <= (aLevel->M3ConvertionProbabilities())[iGamma])
{ iShell = 6;}
else if ( random <= (aLevel->M4ConvertionProbabilities())[iGamma])
{ iShell = 7;}
else if ( random <= (aLevel->M5ConvertionProbabilities())[iGamma])
{ iShell = 8;}
// the following is needed to match the ishell to that used in
// G4AtomicShells
if ( iShell == 9) {
if ( (nucleusZ < 28) && (nucleusZ > 20)) {
iShell--;
} else if ( nucleusZ == 20 || nucleusZ == 19 ) {
iShell = iShell -2;
}
}
//L.Desorgher 02/11/2011
//Atomic shell information is available in Geant4 only up top Z=100
//To extend the photo evaporation code to Z>100 the call
// to G4AtomicShells::GetBindingEnergy should be forbidden for Z>100
bondE = 0.;
if (nucleusZ <=100) {
bondE = G4AtomicShells::GetBindingEnergy(nucleusZ, iShell);
}
if (verbose > 1) {
G4cout << "G4DiscreteGammaTransition: nucleusZ = " <<nucleusZ
<< " , iShell = " << iShell
<< " , Shell binding energy = " << bondE/keV
<< " keV " << G4endl;
}
// last check on energy
if(gammaEnergy > bondE + tolerance) {
orbitE = iShell;
aGamma = false ; // emitted is not a gamma now
gammaEnergy -= bondE;
}
//G4cout << "gammaEnergy = " << gammaEnergy << G4endl;
}
}
G4double tau = aLevel->HalfLife() / G4Pow::GetInstance()->logZ(2);
//09.05.2010 VI rewrite samling of decay time
// assuming ordinary exponential low
gammaCreationTime = 0.;
if(tau > 0.0) { gammaCreationTime = -tau*G4Log(G4UniformRand()); }
}
//G4cout << "G4DiscreteGammaTransition end nGamma= " << nGammas
// << " Egamma= " << gammaEnergy << G4endl;
}
G4double G4DiscreteGammaTransition::GetGammaEnergy()
{
return gammaEnergy;
}
G4double G4DiscreteGammaTransition::GetGammaCreationTime()
{
return gammaCreationTime;
}
void G4DiscreteGammaTransition::SetEnergyFrom(G4double energy)
{
excitation = energy;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4E1Probability.cc
-165
View File
@@ -1,165 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4E1Probability.cc 92144 2015-08-19 14:25:18Z gcosmo $
//
//---------------------------------------------------------------------
//
// Geant4 class G4E1Probability
//
// by V. Lara (May 2003)
//
// Modifications:
// 18.05.2010 V.Ivanchenko trying to speedup the most slow method
// by usage of G4Pow, integer A and introduction of const members
// 17.11.2010 V.Ivanchenko perform general cleanup and simplification
// of integration method; low-limit of integration is defined
// by gamma energy or is zero (was always zero before)
//
#include "G4E1Probability.hh"
#include "Randomize.hh"
#include "G4Pow.hh"
#include "G4Exp.hh"
#include "G4SystemOfUnits.hh"
static const G4double tolerance = 0.1*CLHEP::keV;
G4E1Probability::G4E1Probability():G4VEmissionProbability()
{
G4double x = CLHEP::pi*CLHEP::hbarc;
normC = 1.0 / (x*x);
theLevelDensityPerNucleon = 0.125/MeV;
aLevelDensityParam = sigma0 = Egdp = GammaR = 0.0;
Afrag = 0;
fG4pow = G4Pow::GetInstance();
}
G4E1Probability::~G4E1Probability()
{}
G4double G4E1Probability::EmissionProbDensity(const G4Fragment& frag,
G4double gammaE)
{
// Calculate the probability density here
// From nuclear fragment properties and the excitation energy, calculate
// the probability density for photon evaporation from U to U - gammaE
// (U = nucleus excitation energy, gammaE = total evaporated photon
// energy). Fragment = nuclear fragment BEFORE de-excitation
G4double theProb = 0.0;
if(gammaE > tolerance) {
G4double Uexcite = frag.GetExcitationEnergy();
G4double U = std::max(0.0, Uexcite - gammaE);
// Need a level density parameter.
// For now, just use the constant approximation (not reliable near magic
// nuclei) - is equivalent to G4ConstantLevelDensityParameter class
if(Afrag != frag.GetA_asInt()) {
Afrag = frag.GetA_asInt();
aLevelDensityParam = Afrag*theLevelDensityPerNucleon;
// Define constants for the photoabsorption cross-section (the reverse
// process of our de-excitation)
sigma0 = 2.5 * Afrag * millibarn;
Egdp = (40.3 / fG4pow->powZ(Afrag,0.2) )*MeV;
GammaR = 0.30 * Egdp;
}
// VI reduce number of calls to exp
G4double levelDens =
G4Exp(2*(std::sqrt(aLevelDensityParam*U)-
std::sqrt(aLevelDensityParam*Uexcite)));
//G4cout<<" Uexcite, gammaE = "<<Uexcite<<" "<<gammaE<<G4endl;
//cout<<" lev density param = "<<aLevelDensityParam<<G4endl;
//cout<<" level densities = "<<levelDensBef<<" "<<levelDensAft<<G4endl;
//cout<<" sigma0 = "<<sigma0<<G4endl;
//cout<<" Egdp, GammaR = "<<Egdp<<" "<<GammaR<<G4endl;
//cout<<" normC = "<<normC<<G4endl;
// VI implementation 18.05.2010
G4double gammaE2 = gammaE*gammaE;
G4double gammaR2 = gammaE2*GammaR*GammaR;
G4double egdp2 = gammaE2 - Egdp*Egdp;
G4double sigmaAbs = sigma0*gammaR2/(egdp2*egdp2 + gammaR2);
theProb = normC * sigmaAbs * gammaE2 * levelDens;
//G4cout<<" sigmaAbs = "<<sigmaAbs <<" Probability = "<<theProb<<G4endl;
}
return theProb;
}
G4double G4E1Probability::EmissionProbability(const G4Fragment& frag,
G4double gammaE)
{
// From nuclear fragment properties and the excitation energy, calculate
// the probability for photon evaporation down to last ground level.
// fragment = nuclear fragment BEFORE de-excitation
G4double upperLim = gammaE;
G4double lowerLim = 0.0;
//G4cout << "G4E1Probability::EmissionProbability: Emin= " << lowerLim
// << " Emax= " << upperLim << G4endl;
if( upperLim - lowerLim <= tolerance) { return 0.0; }
// Need to integrate EmissionProbDensity from lowerLim to upperLim
// and multiply by factor 3 (?!)
G4double integ = EmissionIntegration(frag,lowerLim,upperLim);
return integ;
}
G4double G4E1Probability::EmissionIntegration(const G4Fragment& frag,
G4double lowLim, G4double upLim)
{
// Simple integration
// VI replace by direct integration over 100 point
static const G4int numIters = 100;
G4double Step = (upLim-lowLim)/G4double(numIters);
G4double res = 0.0;
G4double x = lowLim - 0.5*Step;
for(G4int i = 0; i < numIters; ++i) {
x += Step;
res += EmissionProbDensity(frag, x);
}
if(res > 0.0) { res *= Step; }
else { res = 0.0; }
return res;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevel.cc
-350
View File
@@ -1,350 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevel.cc 86986 2014-11-21 13:00:05Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevel
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 24 October 1998
//
// Modifications:
// 06 Oct 2010, M. Kelsey (kelsey@slac.stanford.edu)
// Add friendship for G4NuclearLevelManager; define private
// constructors without vectors.
//
// 09 Sep. 2002, Fan Lei (flei@space.qinetiq.com)
// Added IC probability when calculate the channel probabilities in
// MakeProbabilities().
//
// 21 Nov. 2001, Fan Lei (flei@space.qinetiq.com)
// Added K->N+ internal conversion coefficiencies and their access
// functions.
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added half-life, angular momentum, parity, emissioni type
// reading from experimental data.
//
// 28 October 2010, V.Ivanchenko moved copy constructor to source, cleanup
//
// -------------------------------------------------------------------
#include "G4NuclearLevel.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
G4int G4NuclearLevel::Increment(G4int aF)
{
static G4ThreadLocal G4int instanceCount = 0;
instanceCount+=aF;
return instanceCount;
}
G4NuclearLevel::G4NuclearLevel()
: _energy(0.), _halfLife(0.), _angularMomentum(0.), _nGammas(0) {
// G4cout << "####### Incrementing "<<Increment(1)<<G4endl;
}
G4NuclearLevel::G4NuclearLevel(G4double energy, G4double halfLife,
G4double angularMomentum)
: _energy(energy), _halfLife(halfLife), _angularMomentum(angularMomentum),
_nGammas(0) {
// G4cout << "####### Incrementing "<<Increment(1)<<G4endl;
}
G4NuclearLevel::G4NuclearLevel(G4double energy, G4double halfLife,
G4double angularMomentum,
const std::vector<G4double>& eGamma,
const std::vector<G4double>& wGamma,
const std::vector<G4double>& polarities,
const std::vector<G4double>& kCC, const std::vector<G4double>& l1CC,
const std::vector<G4double>& l2CC, const std::vector<G4double>& l3CC,
const std::vector<G4double>& m1CC, const std::vector<G4double>& m2CC,
const std::vector<G4double>& m3CC, const std::vector<G4double>& m4CC,
const std::vector<G4double>& m5CC, const std::vector<G4double>& nPlusCC,
const std::vector<G4double>& totalCC)
: _energies(eGamma), _weights(wGamma), _polarities(polarities),
_kCC(kCC), _l1CC(l1CC), _l2CC(l2CC), _l3CC(l3CC),
_m1CC(m1CC), _m2CC(m2CC), _m3CC(m3CC), _m4CC(m4CC), _m5CC(m5CC),
_nPlusCC(nPlusCC), _totalCC(totalCC),
_energy(energy), _halfLife(halfLife), _angularMomentum(angularMomentum)
{
Finalize();
// G4cout << "####### Incrementing "<<Increment(1)<<G4endl;
}
G4NuclearLevel::~G4NuclearLevel()
{
// G4cout << "####### Decrementing "<<Increment(-1)<<G4endl;
}
G4bool G4NuclearLevel::operator==(const G4NuclearLevel &right) const
{
return (this == (G4NuclearLevel *) &right);
}
G4bool G4NuclearLevel::operator!=(const G4NuclearLevel &right) const
{
return (this != (G4NuclearLevel *) &right);
}
G4bool G4NuclearLevel::operator<(const G4NuclearLevel &right) const
{
if (_energy < right.Energy()) return true;
else return false;
}
const std::vector<G4double>& G4NuclearLevel::GammaEnergies() const
{
return _energies;
}
const std::vector<G4double>& G4NuclearLevel::GammaWeights() const
{
return _weights;
}
const std::vector<G4double>& G4NuclearLevel::GammaProbabilities() const
{
return _prob;
}
const std::vector<G4double>& G4NuclearLevel::GammaCumulativeProbabilities() const
{
return _cumProb;
}
const std::vector<G4double>& G4NuclearLevel::GammaPolarities() const
{
return _polarities;
}
const std::vector<G4double>& G4NuclearLevel::KConvertionProbabilities() const
{
return _kCC;
}
const std::vector<G4double>& G4NuclearLevel::L1ConvertionProbabilities() const
{
return _l1CC;
}
const std::vector<G4double>& G4NuclearLevel::L2ConvertionProbabilities() const
{
return _l2CC;
}
const std::vector<G4double>& G4NuclearLevel::L3ConvertionProbabilities() const
{
return _l3CC;
}
const std::vector<G4double>& G4NuclearLevel::M1ConvertionProbabilities() const
{
return _m1CC;
}
const std::vector<G4double>& G4NuclearLevel::M2ConvertionProbabilities() const
{
return _m2CC;
}
const std::vector<G4double>& G4NuclearLevel::M3ConvertionProbabilities() const
{
return _m3CC;
}
const std::vector<G4double>& G4NuclearLevel::M4ConvertionProbabilities() const
{
return _m4CC;
}
const std::vector<G4double>& G4NuclearLevel::M5ConvertionProbabilities() const
{
return _m5CC;
}
const std::vector<G4double>& G4NuclearLevel::NPlusConvertionProbabilities() const
{
return _nPlusCC;
}
const std::vector<G4double>& G4NuclearLevel::TotalConvertionProbabilities() const
{
return _totalCC;
}
G4double G4NuclearLevel::Energy() const
{
return _energy;
}
G4double G4NuclearLevel::AngularMomentum() const
{
return _angularMomentum;
}
G4double G4NuclearLevel::HalfLife() const
{
return _halfLife;
}
G4int G4NuclearLevel::NumberOfGammas() const
{
return _nGammas;
}
void G4NuclearLevel::PrintAll() const
{
G4cout << "---- Level energy = " << _energy << ", angular momentum = "
<< _angularMomentum << ", half life " << _halfLife
<< ", " << _nGammas << " photons" << G4endl;
G4int i;
G4cout << " Gammas: ";
for (i=0; i<_nGammas; i++) { G4cout << _energies[i] << " "; }
G4cout << G4endl << " Weights: ";
for (i=0; i<_nGammas; i++) { G4cout << _weights[i] << " "; }
G4cout << G4endl << " Relative transition probabilities ";
for (i=0; i<_nGammas; i++) { G4cout << _prob[i] << " "; }
G4cout << G4endl << " Cumulative probabilities: ";
for (i=0; i<_nGammas; i++) { G4cout << _cumProb[i] << " "; }
G4cout << G4endl << " Polarities: ";
for (i=0; i<_nGammas; i++) { G4cout << _polarities[i] << " "; }
G4cout << G4endl;
}
void G4NuclearLevel::PrintLevels() const
{
G4cout << " Eexc(MeV)= " << _energy
<< " Time(ns)= " << _halfLife/ns << " Ntrans= " << _nGammas
<< G4endl;
}
void G4NuclearLevel::Finalize() {
_nGammas = _energies.size();
MakeProbabilities();
MakeCumProb();
}
void G4NuclearLevel::MakeProbabilities()
{
G4double sum = 0.;
G4int i = 0;
for (i=0; i<_nGammas; i++) {
sum += _weights[i]*(1.+_totalCC[i]);
}
if (sum <= 0.) _prob.resize(_nGammas, 1./_nGammas); // Fast fill
else {
_prob.reserve(_nGammas);
for (i=0; i<_nGammas; i++) {
_prob.push_back(_weights[i]*(1.+_totalCC[i])/sum);
}
}
}
void G4NuclearLevel::MakeCumProb()
{
if (_nGammas <= 0) return;
_cumProb.reserve(_nGammas);
G4double sum = _prob[0];
_cumProb.push_back(sum);
for (G4int i=1; i<_nGammas; i++) {
sum += _prob[i];
_cumProb.push_back(sum);
}
}
G4NuclearLevel& G4NuclearLevel::operator=(const G4NuclearLevel &right)
{
if(this != &right)
{
_energies = right._energies;
_weights =right._weights;
_prob =right._prob;
_cumProb =right._cumProb;
_polarities =right._polarities;
_kCC = right._kCC;
_l1CC =right._l1CC;
_l2CC =right._l2CC;
_l3CC =right._l3CC;
_m1CC = right._m1CC;
_m2CC = right._m2CC;
_m3CC = right._m3CC;
_m4CC = right._m4CC;
_m5CC = right._m5CC;
_nPlusCC = right._nPlusCC;
_totalCC = right._totalCC;
_energy = right._energy;
_halfLife = right._halfLife;
_angularMomentum = right._angularMomentum;
_nGammas = right._nGammas;
}
return *this;
}
G4NuclearLevel::G4NuclearLevel(const G4NuclearLevel &right)
{
_energies = right._energies;
_weights =right._weights;
_prob =right._prob;
_cumProb =right._cumProb;
_polarities =right._polarities;
_kCC = right._kCC;
_l1CC =right._l1CC;
_l2CC =right._l2CC;
_l3CC =right._l3CC;
_m1CC = right._m1CC;
_m2CC = right._m2CC;
_m3CC = right._m3CC;
_m4CC = right._m4CC;
_m5CC = right._m5CC;
_nPlusCC = right._nPlusCC;
_totalCC = right._totalCC;
_energy = right._energy;
_halfLife = right._halfLife;
_angularMomentum = right._angularMomentum;
_nGammas = right._nGammas;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevelManager.cc
-428
View File
@@ -1,428 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevelManager.cc 93357 2015-10-19 13:40:13Z gcosmo $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4NuclearLevelManager
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 24 October 1998
//
// Modifications:
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added half-life, angular momentum, parity, emissioni type
// reading from experimental data.
// 02 May 2003, Vladimir Ivanchenko remove rublic copy constructor
// 06 Oct 2010, M. Kelsey -- Use object storage, not pointers, drop
// public access to list, simplify list construction
// -------------------------------------------------------------------
#include <stdlib.h>
#include <fstream>
#include <sstream>
#include <algorithm>
#include "G4NuclearLevelManager.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4NuclearLevel.hh"
#include "G4ios.hh"
#include "G4HadronicException.hh"
#include "G4HadTmpUtil.hh"
#include "G4NucleiProperties.hh"
#include "G4PhysicalConstants.hh"
G4double G4NuclearLevelManager::_levelEnergy=0.;
G4double G4NuclearLevelManager::_gammaEnergy=0.;
G4double G4NuclearLevelManager::_probability=0.;
G4double G4NuclearLevelManager::_polarity=0.;
G4double G4NuclearLevelManager::_halfLife=0.;
G4double G4NuclearLevelManager::_angularMomentum=0.;
G4double G4NuclearLevelManager::_kCC=0.;
G4double G4NuclearLevelManager::_l1CC=0.;
G4double G4NuclearLevelManager::_l2CC=0.;
G4double G4NuclearLevelManager::_l3CC=0.;
G4double G4NuclearLevelManager::_m1CC=0.;
G4double G4NuclearLevelManager::_m2CC=0.;
G4double G4NuclearLevelManager::_m3CC=0.;
G4double G4NuclearLevelManager::_m4CC=0.;
G4double G4NuclearLevelManager::_m5CC=0.;
G4double G4NuclearLevelManager::_nPlusCC=0.;
G4double G4NuclearLevelManager::_totalCC=0.;
G4NuclearLevelManager::G4NuclearLevelManager(G4int Z, G4int A,
const G4String& filename) :
_nucleusA(A), _nucleusZ(Z), _validity(false),
_levels(0)
{
if (A <= 0 || Z <= 0 || Z > A ) {
throw G4HadronicException(__FILE__, __LINE__,
"==== G4NuclearLevelManager ==== (Z,A) <0, or Z>A");
}
MakeLevels(filename);
/*
G4cout << "+++++ New G4NuclearLevelManager Z= " << Z << " A= " << A
<< " " << _levels;
if(_levels) { G4cout << " Nlevels= " << _levels->size(); }
G4cout << G4endl;
*/
}
G4NuclearLevelManager::~G4NuclearLevelManager()
{
ClearLevels();
}
void G4NuclearLevelManager::SetNucleus(G4int Z, G4int A, const G4String& filename)
{
if (A <= 0 || Z <= 0 || Z > A ) {
throw G4HadronicException(__FILE__, __LINE__,
"==== G4NuclearLevelManager ==== (Z,A) <0, or Z>A");
}
if (_nucleusZ != Z || _nucleusA != A)
{
_nucleusA = A;
_nucleusZ = Z;
MakeLevels(filename);
}
}
const G4NuclearLevel* G4NuclearLevelManager::GetLevel(G4int i) const {
return (i>=0 && i<NumberOfLevels()) ? (*_levels)[i] : 0;
}
const G4NuclearLevel*
G4NuclearLevelManager::NearestLevel(G4double energy, G4double) const
{
if (NumberOfLevels() <= 0) return 0;
G4int iNear = -1;
//G4cout << "G4NuclearLevelManager::NearestLevel E(MeV)= "
// << energy/MeV << " dEmax(MeV)= " << eDiffMax/MeV << G4endl;
G4double diff = 1.e+10;
for (unsigned int i=0; i<_levels->size(); ++i)
{
G4double e = GetLevel(i)->Energy();
G4double eDiff = std::fabs(e - energy);
//G4cout << i << ". eDiff(MeV)= " << eDiff/MeV << G4endl;
if (eDiff <= diff)
{
diff = eDiff;
iNear = i;
}
}
return GetLevel(iNear); // Includes range checking on iNear
}
G4double G4NuclearLevelManager::MinLevelEnergy() const
{
return (NumberOfLevels() > 0) ? _levels->front()->Energy() : 9999.*GeV;
}
G4double G4NuclearLevelManager::MaxLevelEnergy() const
{
return (NumberOfLevels() > 0) ? _levels->back()->Energy() : 0.*GeV;
}
const G4NuclearLevel* G4NuclearLevelManager::HighestLevel() const
{
return (NumberOfLevels() > 0) ? _levels->front() : 0;
}
const G4NuclearLevel* G4NuclearLevelManager::LowestLevel() const
{
return (NumberOfLevels() > 0) ? _levels->back() : 0;
}
G4bool G4NuclearLevelManager::Read(std::ifstream& dataFile)
{
G4bool goodRead = ReadDataLine(dataFile);
if (goodRead) ProcessDataLine();
return goodRead;
}
// NOTE: Standard stream I/O generates a 45 byte std::string per item!
G4bool G4NuclearLevelManager::ReadDataLine(std::ifstream& dataFile) {
/***** DO NOT USE REGULAR STREAM I/O
G4bool result = true;
if (dataFile >> _levelEnergy)
{
dataFile >> _gammaEnergy >> _probability >> _polarity >> _halfLife
>> _angularMomentum >> _totalCC >> _kCC >> _l1CC >> _l2CC
>> _l3CC >> _m1CC >> _m2CC >> _m3CC >> _m4CC >> _m5CC
>> _nPlusCC;
}
else result = false;
*****/
// Each item will return iostream status
return (ReadDataItem(dataFile, _levelEnergy) &&
ReadDataItem(dataFile, _gammaEnergy) &&
ReadDataItem(dataFile, _probability) &&
ReadDataItem(dataFile, _polarity) &&
ReadDataItem(dataFile, _halfLife) &&
ReadDataItem(dataFile, _angularMomentum) &&
ReadDataItem(dataFile, _totalCC) &&
ReadDataItem(dataFile, _kCC) &&
ReadDataItem(dataFile, _l1CC) &&
ReadDataItem(dataFile, _l2CC) &&
ReadDataItem(dataFile, _l3CC) &&
ReadDataItem(dataFile, _m1CC) &&
ReadDataItem(dataFile, _m2CC) &&
ReadDataItem(dataFile, _m3CC) &&
ReadDataItem(dataFile, _m4CC) &&
ReadDataItem(dataFile, _m5CC) &&
ReadDataItem(dataFile, _nPlusCC) );
}
G4bool
G4NuclearLevelManager::ReadDataItem(std::istream& dataFile, G4double& x)
{
// G4bool okay = (dataFile >> buffer) != 0; // Get next token
// if (okay) x = strtod(buffer, NULL);
char buffer[30];
for(G4int i=0; i<30; ++i) { buffer[i] = 0; }
G4bool okay = true;
dataFile >> buffer;
if(dataFile.fail()) { okay = false; }
else { x = strtod(buffer, NULL); }
return okay;
}
void G4NuclearLevelManager::ProcessDataLine()
{
const G4double minProbability = 1e-8;
// Assign units for dimensional quantities
_levelEnergy *= keV;
_gammaEnergy *= keV;
_halfLife *= second;
// The following adjustment is needed to take care of anomalies in
// data files, where some transitions show up with relative probability
// zero
if (_probability < minProbability) _probability = minProbability;
// the folowwing is to convert icc probability to accumulative ones
_l1CC += _kCC;
_l2CC += _l1CC;
_l3CC += _l2CC;
_m1CC += _l3CC;
_m2CC += _m1CC;
_m3CC += _m2CC;
_m4CC += _m3CC;
_m5CC += _m4CC;
_nPlusCC += _m5CC;
if (_nPlusCC!=0) { // Normalize to probabilities
_kCC /= _nPlusCC;
_l1CC /= _nPlusCC;
_l2CC /= _nPlusCC;
_l3CC /= _nPlusCC;
_m1CC /= _nPlusCC;
_m2CC /= _nPlusCC;
_m3CC /= _nPlusCC;
_m4CC /= _nPlusCC;
_m5CC /= _nPlusCC;
_nPlusCC /= _nPlusCC;
} else { // Total was zero, reset to unity
_kCC = 1;
_l1CC = 1;
_l2CC = 1;
_l3CC = 1;
_m1CC = 1;
_m2CC = 1;
_m3CC = 1;
_m4CC = 1;
_m5CC = 1;
_nPlusCC = 1;
}
// G4cout << "Read " << _levelEnergy << " " << _gammaEnergy << " " << _probability << G4endl;
}
void G4NuclearLevelManager::ClearLevels()
{
_validity = false;
if (NumberOfLevels() > 0) {
std::for_each(_levels->begin(), _levels->end(), DeleteLevel());
_levels->clear();
}
delete _levels;
_levels = 0;
}
void G4NuclearLevelManager::MakeLevels(const G4String& filename)
{
_validity = false;
if (NumberOfLevels() > 0) ClearLevels(); // Discard existing data
std::ifstream inFile(filename, std::ios::in);
if (! inFile)
{
#ifdef GAMMAFILEWARNING
if (_nucleusZ > 10) G4cout << " G4NuclearLevelManager: nuclide ("
<< _nucleusZ << "," << _nucleusA
<< ") does not have a gamma levels file" << G4endl;
#endif
return;
}
_levels = new G4PtrLevelVector;
// Read individual gamma data and fill levels for this nucleus
G4NuclearLevel* thisLevel = 0;
G4int nData = 0;
// Loop checking, 05-Aug-2015, Vladimir Ivanchenko
while (Read(inFile)) {
thisLevel = UseLevelOrMakeNew(thisLevel); // May create new pointer
AddDataToLevel(thisLevel);
nData++; // For debugging purposes
}
FinishLevel(thisLevel); // Final must be completed by hand
// ---- MGP ---- Don't forget to close the file
inFile.close();
// G4cout << " ==== MakeLevels ===== " << nData << " data read " << G4endl;
G4PtrSort<G4NuclearLevel>(_levels);
_validity = true;
return;
}
G4NuclearLevel*
G4NuclearLevelManager::UseLevelOrMakeNew(G4NuclearLevel* level)
{
if (level && _levelEnergy == level->Energy()) return level; // No change
if (level) FinishLevel(level); // Save what we have up to now
// G4cout << "Making a new level... " << _levelEnergy << G4endl;
return new G4NuclearLevel(_levelEnergy, _halfLife, _angularMomentum);
}
void G4NuclearLevelManager::AddDataToLevel(G4NuclearLevel* level)
{
if (!level) return; // Sanity check
level->_energies.push_back(_gammaEnergy);
level->_weights.push_back(_probability);
level->_polarities.push_back(_polarity);
level->_kCC.push_back(_kCC);
level->_l1CC.push_back(_l1CC);
level->_l2CC.push_back(_l2CC);
level->_l3CC.push_back(_l3CC);
level->_m1CC.push_back(_m1CC);
level->_m2CC.push_back(_m2CC);
level->_m3CC.push_back(_m3CC);
level->_m4CC.push_back(_m4CC);
level->_m5CC.push_back(_m5CC);
level->_nPlusCC.push_back(_nPlusCC);
level->_totalCC.push_back(_totalCC);
}
void G4NuclearLevelManager::FinishLevel(G4NuclearLevel* level)
{
if (!level || !_levels) return; // Sanity check
level->Finalize();
_levels->push_back(level);
}
void G4NuclearLevelManager::PrintAll()
{
G4int nLevels = NumberOfLevels();
G4cout << " ==== G4NuclearLevelManager ==== (" << _nucleusZ << ", " << _nucleusA
<< ") has " << nLevels << " levels" << G4endl
<< "Highest level is at energy " << MaxLevelEnergy() << " MeV "
<< G4endl << "Lowest level is at energy " << MinLevelEnergy()
<< " MeV " << G4endl;
for (G4int i=0; i<nLevels; ++i) {
GetLevel(i)->PrintAll();
}
}
void G4NuclearLevelManager::PrintLevels()
{
G4int nLevels = NumberOfLevels();
G4double efermi = G4NucleiProperties::GetNuclearMass(_nucleusA-1, _nucleusZ)
+ neutron_mass_c2 -
G4NucleiProperties::GetNuclearMass(_nucleusA, _nucleusZ);
G4cout << "Z= " << _nucleusZ << " A= " << _nucleusA
<< " " << nLevels << " levels"
<< " Efermi(MeV)= " << efermi << G4endl;
for (G4int i=0; i<nLevels; ++i) {
GetLevel(i)->PrintLevels();
}
}
G4NuclearLevelManager::G4NuclearLevelManager(const G4NuclearLevelManager &right)
{
_nucleusA = right._nucleusA;
_nucleusZ = right._nucleusZ;
_validity = right._validity;
if (right._levels != 0)
{
_levels = new G4PtrLevelVector;
G4int n = right._levels->size();
G4int i;
for (i=0; i<n; ++i)
{
_levels->push_back(new G4NuclearLevel(*(right.GetLevel(i))));
}
G4PtrSort<G4NuclearLevel>(_levels);
}
else
{
_levels = 0;
}
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevelStore.cc
-188
View File
@@ -1,188 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclearLevelStore.cc 88406 2015-02-18 09:13:29Z gcosmo $
//
// 06-10-2010 M. Kelsey -- Drop static data members.
// 17-11-2010 V. Ivanchenko - make as a classical singleton.
// 17-10-2011 V. L. Desorgher - allows to define separate datafile for
// given isotope
// 06-01-2012 V. Ivanchenko - cleanup the code; new method GetLevelManager
// 19-11-2014 M. Asai - protection against reading the same file from
// more than one worker threads
//
#include "G4NuclearLevelStore.hh"
#include <sstream>
#include <fstream>
G4ThreadLocal G4NuclearLevelStore* G4NuclearLevelStore::theInstance = 0;
#ifdef G4MULTITHREADED
G4NuclearLevelStore* G4NuclearLevelStore::theShadowInstance = 0;
G4Mutex G4NuclearLevelStore::nuclearLevelStoreMutex = G4MUTEX_INITIALIZER;
#endif
G4NuclearLevelStore* G4NuclearLevelStore::GetInstance()
{
if(!theInstance) {
static G4ThreadLocalSingleton<G4NuclearLevelStore> inst;
theInstance = inst.Instance();
}
#ifdef G4MULTITHREADED
if(!theShadowInstance) {
static G4NuclearLevelStore shadowInst;
theShadowInstance = &shadowInst;
}
#endif
return theInstance;
}
G4NuclearLevelStore::G4NuclearLevelStore()
{
userFiles = false;
char* env = getenv("G4LEVELGAMMADATA");
if (env == 0)
{
G4cout << "G4NuclarLevelStore: please set the G4LEVELGAMMADATA environment variable\n";
dirName = "";
}
else
{
dirName = env;
dirName += '/';
}
}
G4NuclearLevelStore::~G4NuclearLevelStore()
{
#ifdef G4MULTITHREADED
if(this==theShadowInstance) // G4NuclearLevelManager object should be deleted only by the master
{
#endif
ManagersMap::iterator i;
for (i = theManagers.begin(); i != theManagers.end(); ++i)
{ delete i->second; }
#ifdef G4MULTITHREADED
}
#endif
}
void
G4NuclearLevelStore::AddUserEvaporationDataFile(G4int Z, G4int A,
const G4String& filename)
{
if (Z<1 || A<2) {
G4cout<<"G4NuclearLevelStore::AddUserEvaporationDataFile "
<<" Z= " << Z << " and A= " << A << " not valid!"<<G4endl;
}
std::ifstream DecaySchemeFile(filename);
if (DecaySchemeFile){
G4int ID_ion=Z*1000+A;//A*1000+Z;
theUserDataFiles[ID_ion]=filename;
userFiles = true;
}
else {
G4cout<<"The file "<<filename<<" does not exist!"<<G4endl;
}
}
G4String
G4NuclearLevelStore::GenerateFileName(G4int Z, G4int A) const
{
std::ostringstream streamName;
streamName << 'z' << Z << ".a" << A;
G4String name(streamName.str());
return name;
}
G4NuclearLevelManager*
G4NuclearLevelStore::GetManager(G4int Z, G4int A)
{
G4NuclearLevelManager * result = 0;
if (A < 1 || Z < 1 || A < Z)
{
//G4cout << "G4NuclearLevelStore::GetManager: Wrong values Z = " << Z
// << " A = " << A << '\n';
return result;
}
// Generate the key = filename
G4int key = Z*1000+A; //GenerateKey(Z,A);
// Check if already exists that key
ManagersMap::iterator idx = theManagers.find(key);
#ifdef G4MULTITHREADED
// If doesn't exists then check the master
if ( idx == theManagers.end() )
{
G4MUTEXLOCK(&G4NuclearLevelStore::nuclearLevelStoreMutex);
ManagersMap::iterator idxS = theShadowInstance->theManagers.find(key);
if ( idxS == theShadowInstance->theManagers.end() )
{
// If doesn't exists then create it
G4String file = dirName + GenerateFileName(Z,A);
//Check if data have been provided by the user
if(userFiles) {
G4String file1 = theUserDataFiles[key];//1000*A+Z];
if (file1 != "") { file = file1; }
}
result = new G4NuclearLevelManager(Z,A,file);
theShadowInstance->theManagers.insert(std::make_pair(key,result));
}
else
{
// if it exists in the master
result = idxS->second;
}
// register to the local map
theManagers.insert(std::make_pair(key,result));
G4MUTEXUNLOCK(&G4NuclearLevelStore::nuclearLevelStoreMutex);
}
#else
// If doesn't exists then create it
if ( idx == theManagers.end() )
{
G4String file = dirName + GenerateFileName(Z,A);
//Check if data have been provided by the user
if(userFiles) {
G4String file1 = theUserDataFiles[key];//1000*A+Z];
if (file1 != "") { file = file1; }
}
result = new G4NuclearLevelManager(Z,A,file);
theManagers.insert(std::make_pair(key,result));
}
#endif
else
// But if it exists...
{
result = idx->second;
}
return result;
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4PhotonEvaporationOLD.cc
-248
View File
@@ -1,248 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PhotonEvaporationOLD.cc 91873 2015-08-07 17:50:24Z vnivanch $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4PhotonEvaporationOLD
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 8 March 2002, Fan Lei (flei@space.qinetiq.com)
//
// Implementation of Internal Convertion process in discrete deexcitation
// The following public methods have been added.
//
// void SetICM (G4bool);
// void CallFromRDM(G4bool);
// void SetMaxHalfLife(G4double) ;
// void SetEOccupancy( G4ElectronOccupancy eOccupancy) ;
// G4ElectronOccupancy GetEOccupancy () ;
//
// 11 May 2010, V.Ivanchenko add implementation of EmittedFragment and
// BreakUpFragment methods; cleanup logic
//
// 22 October 2015, V.Ivanchenko renamed to G4PhotonEvaporationOLD
//
// -------------------------------------------------------------------
//
#include "G4PhotonEvaporationOLD.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4Gamma.hh"
#include "G4LorentzVector.hh"
#include "G4VGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4FragmentVector.hh"
#include "G4ContinuumGammaDeexcitation.hh"
#include "G4DiscreteGammaDeexcitation.hh"
#include "G4E1Probability.hh"
#include "G4NuclearLevelStore.hh"
static const G4double tolerance = 0.1*CLHEP::keV;
G4PhotonEvaporationOLD::G4PhotonEvaporationOLD(const G4String & aName)
: G4VEvaporationChannel(aName),
verbose(0), myOwnProbAlgorithm(true),
eOccupancy(0), vShellNumber(-1), gammaE(0.)
{
G4Exception ("G4PhotonEvaporationOLD: ", "had001", JustWarning,
"This class is obsolete and will be removed for the next public release");
probAlgorithm = new G4E1Probability;
contDeexcitation = new G4ContinuumGammaDeexcitation;
G4DiscreteGammaDeexcitation* p = new G4DiscreteGammaDeexcitation();
discrDeexcitation = p;
p->SetICM(false);
// Time limits
G4double timeLimit = DBL_MAX;
char* env = getenv("G4AddTimeLimitToPhotonEvaporation");
if(env) { timeLimit = 1.e-16*second; }
// Time for short-cut simulation of photon evaporationOLD
p->SetTimeLimit(timeLimit);
// Default time limit for isomere production
SetMaxHalfLife(DBL_MAX);
// SetMaxHalfLife(1.e-6*second);
nucleus = 0;
}
G4PhotonEvaporationOLD::~G4PhotonEvaporationOLD()
{
if(myOwnProbAlgorithm) delete probAlgorithm;
delete discrDeexcitation;
delete contDeexcitation;
}
G4Fragment* G4PhotonEvaporationOLD::EmittedFragment(G4Fragment* aNucleus)
{
//G4cout << "G4PhotonEvaporationOLD::EmittedFragment" << G4endl;
vShellNumber = -1;
G4Fragment* gamma = 0;
if(contDeexcitation->CanDoTransition(aNucleus)) {
gamma = contDeexcitation->GenerateGamma(aNucleus);
if(gamma && verbose > 1) {
G4cout << "G4PhotonEvaporationOLD::EmittedFragment continium deex: "
<< gamma << G4endl;
G4cout << " Residual: " << aNucleus << G4endl;
}
} else if(discrDeexcitation->CanDoTransition(aNucleus)) {
// Do one photon emission by the discrete deexcitation
gamma = discrDeexcitation->GenerateGamma(aNucleus);
if(gamma) {
vShellNumber = discrDeexcitation->GetVacantSN();
if (verbose > 1) {
G4cout << "G4PhotonEvaporationOLD::EmittedFragment discrete deex: "
<< gamma << G4endl;
G4cout << " Residual: " << aNucleus << G4endl;
}
}
}
return gamma;
}
G4bool G4PhotonEvaporationOLD::BreakUpChain(G4FragmentVector* products,
G4Fragment* aNucleus)
{
//G4cout << "G4PhotonEvaporationOLD::BreakUpChain" << G4endl;
G4Fragment* gamma = 0;
// one continues emission is not excluded
if(contDeexcitation->CanDoTransition(aNucleus)) {
gamma = contDeexcitation->GenerateGamma(aNucleus);
if(gamma) {
if (verbose > 1) {
G4cout << "G4PhotonEvaporationOLD::EmittedFragment continium deex: "
<< gamma << G4endl;
G4cout << " Residual: " << aNucleus << G4endl;
}
products->push_back(gamma);
}
}
// main emissions are discrete
discrDeexcitation->DoChain(products, aNucleus);
return false;
}
G4FragmentVector* G4PhotonEvaporationOLD::BreakUpFragment(G4Fragment* aNucleus)
{
//G4cout << "G4PhotonEvaporationOLD::BreakUpFragment" << G4endl;
G4FragmentVector* products = new G4FragmentVector();
BreakUpChain(products, aNucleus);
return products;
}
G4FragmentVector* G4PhotonEvaporationOLD::BreakUp(const G4Fragment& theNucleus)
{
//G4cout << "G4PhotonEvaporationOLD::BreakUp" << G4endl;
G4Fragment* aNucleus = new G4Fragment(theNucleus);
G4FragmentVector* products = new G4FragmentVector();
//discrDeexcitation->DoChain(products, aNucleus);
BreakUpChain(products, aNucleus);
products->push_back(aNucleus);
return products;
}
G4FragmentVector* G4PhotonEvaporationOLD::BreakItUp(const G4Fragment& theNucleus)
{
//G4cout << "G4PhotonEvaporationOLD::BreakItUp" << G4endl;
G4Fragment* aNucleus = new G4Fragment(theNucleus);
G4FragmentVector* products = new G4FragmentVector();
BreakUpChain(products, aNucleus);
products->push_back(aNucleus);
return products;
}
G4double
G4PhotonEvaporationOLD::GetEmissionProbability(G4Fragment* theNucleus)
{
G4double prob = 0.0;
G4int Z = theNucleus->GetZ_asInt();
G4int A = theNucleus->GetA_asInt();
G4double eexc = theNucleus->GetExcitationEnergy();
if(0 < Z && Z < A && eexc > tolerance) {
prob = probAlgorithm->EmissionProbability(*theNucleus, eexc);
}
return prob;
}
void
G4PhotonEvaporationOLD::SetEmissionStrategy(G4VEmissionProbability * alg)
{
if(myOwnProbAlgorithm) { delete probAlgorithm; }
probAlgorithm = alg;
myOwnProbAlgorithm = false;
}
void G4PhotonEvaporationOLD::SetVerboseLevel(G4int verb)
{
verbose = verb;
contDeexcitation->SetVerboseLevel(verbose);
discrDeexcitation->SetVerboseLevel(verbose);
}
void G4PhotonEvaporationOLD::SetICM(G4bool ic)
{
static_cast<G4DiscreteGammaDeexcitation*>(discrDeexcitation)->SetICM(ic);
}
void G4PhotonEvaporationOLD::SetMaxHalfLife(G4double hl)
{
static_cast<G4DiscreteGammaDeexcitation*>(discrDeexcitation)->SetHL(hl);
}
void G4PhotonEvaporationOLD::SetTimeLimit(G4double val)
{
discrDeexcitation->SetTimeLimit(val);
}
void G4PhotonEvaporationOLD::RDMForced(G4bool fromRDM)
{
static_cast<G4DiscreteGammaDeexcitation*>(discrDeexcitation)->SetRDM(fromRDM);
}
void G4PhotonEvaporationOLD::SetEOccupancy(G4ElectronOccupancy eo)
{
discrDeexcitation->SetEO(eo);
}
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4VGammaDeexcitation.cc
-214
View File
@@ -1,214 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VGammaDeexcitation.cc 94676 2015-12-02 09:51:20Z gunter $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4VGammaDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 23 October 1998
//
// Modifications:
//
// 21 Nov 2001, Fan Lei (flei@space.qinetiq.com)
// Modified GenerateGamma() and UpdateUncleus() for implementation
// of Internal Conversion processs
//
// 15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
// Added creation time evaluation for products of evaporation
//
// 19 April 2010, J. M. Quesada calculations in CM system
// pending final boost to lab system (not critical)
//
// 23 April 2010, V.Ivanchenko rewite kinematic part using PDG formula
// for 2-body decay
//
// 07 May 2011, V.Ivanchenko implement check ICM flag - produce or not e-
//
// -------------------------------------------------------------------
#include "G4VGammaDeexcitation.hh"
#include "globals.hh"
#include "G4PhysicalConstants.hh"
#include "Randomize.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4LorentzVector.hh"
#include "G4VGammaTransition.hh"
#include "G4Fragment.hh"
#include "G4FragmentVector.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "G4DiscreteGammaTransition.hh"
G4VGammaDeexcitation::G4VGammaDeexcitation(): _transition(0), _verbose(0),
_electronO (0), _vSN(-1)
{
_tolerance = 0.1*CLHEP::keV;
_timeLimit = DBL_MAX;
}
G4VGammaDeexcitation::~G4VGammaDeexcitation()
{
delete _transition;
}
void G4VGammaDeexcitation::DoChain(G4FragmentVector* products,
G4Fragment* nucleus)
{
if (_verbose > 1) { G4cout << "G4VGammaDeexcitation::DoChain" << G4endl; }
if(CanDoTransition(nucleus)) {
for(size_t i=0; i<100; ++i) {
_transition->SetEnergyFrom(nucleus->GetExcitationEnergy());
G4Fragment* gamma = GenerateGamma(nucleus);
if (gamma) { products->push_back(gamma); }
else { break; }
//G4cout << i << ". Egamma(MeV)= " << gamma->GetMomentum().e()
// << "; new Eex(MeV)= " << nucleus->GetExcitationEnergy()
// << G4endl;
if(nucleus->GetExcitationEnergy() <= _tolerance) { break; }
}
}
if (_verbose > 1) {
G4cout << "G4VGammaDeexcitation::DoChain - end" << G4endl;
}
}
G4Fragment* G4VGammaDeexcitation::GenerateGamma(G4Fragment* aNucleus)
{
G4Fragment * thePhoton = 0;
_vSN = -1;
_transition->SelectGamma(); // it can be conversion electron too
G4double etrans = _transition->GetGammaEnergy();
//L.Desorgher 05/01/2015 need to add the bond energy for correct
// computation of a transition in case of ICM
G4DiscreteGammaTransition* dtransition =
dynamic_cast <G4DiscreteGammaTransition*> (_transition);
G4double bond_energy=0.;
if (dtransition && !dtransition->IsAGamma()) {
bond_energy = dtransition->GetBondEnergy();
}
etrans += bond_energy;
//G4cout << "G4VGammaDeexcitation::GenerateGamma - Etrans(MeV)= "
// << etrans << G4endl;
if(etrans <= 0.0) { return thePhoton; }
// final excitation
G4double excitation = aNucleus->GetExcitationEnergy() - etrans;
if(excitation <= _tolerance) { excitation = 0.0; }
G4double gammaTime = _transition->GetGammaCreationTime();
if (_verbose > 1) {
G4cout << "G4VGammaDeexcitation::GenerateGamma - Edeexc(MeV)= "
<< etrans << "; Time(ns)= " << gammaTime/CLHEP::ns
<< "; left Eexc(MeV)= " << excitation << G4endl;
}
// Do complete Lorentz computation
G4LorentzVector lv = aNucleus->GetMomentum();
G4double Mass = aNucleus->GetGroundStateMass() + excitation;
// select secondary
G4ParticleDefinition* gamma = G4Gamma::Gamma();
if (dtransition && !dtransition->IsAGamma() ) {
gamma = G4Electron::Electron();
_vSN = dtransition->GetOrbitNumber();
_electronO.RemoveElectron(_vSN);
//L. Desorgher 05/01/2015 need to remove atomic bond energy
// of the IC electron
lv += G4LorentzVector(0.0,0.0,0.0,
CLHEP::electron_mass_c2 - bond_energy);
}
G4double cosTheta = 1. - 2. * G4UniformRand();
G4double sinTheta = std::sqrt(1. - cosTheta * cosTheta);
G4double phi = twopi * G4UniformRand();
G4double eMass = gamma->GetPDGMass();
G4LorentzVector Gamma4P;
/*
G4cout << " Mass= " << eMass << " t= " << gammaTime
<< " tlim= " << _timeLimit << G4endl;
*/
// 2-body decay in rest frame
G4double Ecm = lv.mag();
G4ThreeVector bst = lv.boostVector();
G4double GammaEnergy = 0.5*((Ecm - Mass)*(Ecm + Mass) + eMass*eMass)/Ecm;
if(GammaEnergy < eMass) { GammaEnergy = eMass; }
G4double mom = std::sqrt((GammaEnergy - eMass)*(GammaEnergy + eMass));
Gamma4P.set(mom * sinTheta * std::cos(phi),
mom * sinTheta * std::sin(phi),
mom * cosTheta, GammaEnergy);
// Lab system in normal case (_timeLimit = DBL_MAX)
if(gammaTime <= _timeLimit) {
Gamma4P.boost(bst);
lv -= Gamma4P;
} else {
// In exceptional case sample decay at rest at not correct position
// of stopping ion, 4-momentum balance is breaked but gamma energy
// is correct
lv -= Gamma4P;
G4double E = lv.e();
G4double P2= (E - Mass)*(E + Mass);
G4ThreeVector v = lv.vect().unit();
G4double p = 0.0;
if(P2 > 0.0) { p = std::sqrt(P2); }
else { E = Mass; }
lv.set(v.x()*p, v.y()*p, v.z()*p, E);
}
// modified primary fragment
gammaTime += aNucleus->GetCreationTime();
aNucleus->SetMomentum(lv);
aNucleus->SetCreationTime(gammaTime);
// gamma or e- are produced
thePhoton = new G4Fragment(Gamma4P,gamma);
thePhoton->SetCreationTime(gammaTime);
//G4cout << "G4VGammaDeexcitation::GenerateGamma : " << thePhoton << G4endl;
//G4cout << " Left nucleus: " << aNucleus << G4endl;
return thePhoton;
}
source/processes/hadronic/models/parton_string/qgsm/include/G4PomeronCrossSection.hh
-132
View File
@@ -1,132 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4PomeronCrossSection_h
#define G4PomeronCrossSection_h 1
//
// $Id: G4PomeronCrossSection.hh 96952 2016-05-18 12:21:34Z gcosmo $
//
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4PionZero.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZero.hh"
#include "G4KaonZeroShort.hh"
#include "G4KaonZeroLong.hh"
#include "G4Gamma.hh"
class G4PomeronCrossSection
{
public:
G4PomeronCrossSection(const G4ParticleDefinition * );
G4PomeronCrossSection(const G4Proton * );
G4PomeronCrossSection(const G4Neutron * );
G4PomeronCrossSection(const G4PionPlus * );
G4PomeronCrossSection(const G4PionMinus * );
G4PomeronCrossSection(const G4PionZero * );
G4PomeronCrossSection(const G4KaonPlus * );
G4PomeronCrossSection(const G4KaonMinus * );
G4PomeronCrossSection(const G4KaonZero * );
G4PomeronCrossSection(const G4KaonZeroLong * );
G4PomeronCrossSection(const G4KaonZeroShort * );
G4PomeronCrossSection(const G4Gamma * );
~G4PomeronCrossSection();
// s = (center of mass energy)**2
G4double GetTotalCrossSection(const G4double s);
G4double GetDiffractiveCrossSection(const G4double s);
G4double GetElasticCrossSection(const G4double s);
G4double GetInelasticCrossSection(const G4double s);
G4double GetTotalProbability(const G4double s,
const G4double impactsquare);
G4double GetDiffractiveProbability(const G4double s,
const G4double impactsquare);
G4double GetNondiffractiveProbability(const G4double s,
const G4double impactsquare);
G4double GetElasticProbability(const G4double s,
const G4double impactsquare);
G4double GetInelasticProbability(const G4double s,
const G4double impactsquare);
G4double GetCutPomeronProbability(const G4double s,
const G4double impactsquare, const G4int nPomerons);
void Setgamma(const G4double agam); // temporary only! GF.
G4double SoftEikonal(G4double s, G4double impactsquare);
G4double HardEikonal(G4double s, G4double impactsquare);
void Pomeron_S(G4double apomeron_S){ pomeron_S = apomeron_S;}
void Pomeron_Gamma(G4double apomeron_Gamma){ pomeron_Gamma = apomeron_Gamma;}
void Pomeron_C(G4double apomeron_C){ pomeron_C = apomeron_C;}
void Pomeron_Rsquare(G4double apomeron_Rsquare){ pomeron_Rsquare = apomeron_Rsquare;}
void Pomeron_Alpha(G4double apomeron_Alpha){ pomeron_Alpha = apomeron_Alpha;}
void Pomeron_Alphaprime(G4double apomeron_Alphaprime){ pomeron_Alphaprime = apomeron_Alphaprime;}
void Pomeron_Gamma_Hard(G4double apomeron_Gamma_Hard){ pomeron_Gamma_Hard = apomeron_Gamma_Hard;}
void Pomeron_Alpha_Hard(G4double apomeron_Alpha_Hard){ pomeron_Alpha_Hard = apomeron_Alpha_Hard;}
private:
G4double PowerSoft(const G4double s);
G4double PowerHard(const G4double s);
G4double LambdaSoft(const G4double s);
G4double LambdaHard(const G4double s);
G4double Zsoft(const G4double s);
G4double Zhard(const G4double s);
G4PomeronCrossSection();
void InitForNucleon();
void InitForPion();
void InitForKaon();
void InitForGamma();
G4double Expand(G4double z);
inline G4double Z(const G4double Scms);
inline G4double SigP(const G4double Scms);
inline G4double Power(const G4double Scms);
inline G4double Lambda(const G4double s);
inline G4double Eikonal(const G4double s,const G4double impactsquare);
G4double pomeron_Alpha;
G4double pomeron_Alpha_Hard;
G4double pomeron_Alphaprime;
G4double pomeron_C;
G4double pomeron_Gamma;
G4double pomeron_Gamma_Hard;
G4double pomeron_Rsquare;
G4double pomeron_S;
};
#endif
source/processes/hadronic/models/parton_string/qgsm/src/G4PomeronCrossSection.cc
-321
View File
@@ -1,321 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4PomeronCrossSection.cc 96952 2016-05-18 12:21:34Z gcosmo $
//
#include "G4PomeronCrossSection.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4Pow.hh"
#include "G4Exp.hh"
#include "G4Log.hh"
G4PomeronCrossSection::G4PomeronCrossSection() :
pomeron_Alpha(0), pomeron_Alpha_Hard(0), pomeron_Alphaprime(0),
pomeron_C(0), pomeron_Gamma(0), pomeron_Gamma_Hard(0),
pomeron_Rsquare(0), pomeron_S(0)
{}
G4PomeronCrossSection::~G4PomeronCrossSection()
{;}
//**********************************************************************************************
G4PomeronCrossSection::G4PomeronCrossSection(const G4ParticleDefinition * particle)
{
G4int Encoding = std::abs(particle->GetPDGEncoding());
if (std::abs(particle->GetBaryonNumber())!=0)
InitForNucleon();
else if (Encoding/100== 3 || Encoding/10 == 3)
InitForKaon();
else
InitForPion();
}
//**********************************************************************************************
G4PomeronCrossSection::G4PomeronCrossSection(const G4Proton * )
{
InitForNucleon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4Neutron * )
{
InitForNucleon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionPlus * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionMinus * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionZero * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonPlus * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonMinus * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZero * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZeroLong * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZeroShort * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4Gamma * )
{
InitForGamma();
}
G4double G4PomeronCrossSection::GetTotalCrossSection(const G4double S)
{
G4double FZ2= Expand(Z(S)/2);
return SigP(S) * FZ2;
}
G4double G4PomeronCrossSection::GetElasticCrossSection(const G4double S)
{
return SigP(S)/pomeron_C *(Expand(Z(S)/2) - Expand(Z(S)));
}
G4double G4PomeronCrossSection::GetDiffractiveCrossSection(const G4double S)
{
return ( pomeron_C -1) * GetElasticCrossSection(S);
}
G4double G4PomeronCrossSection::GetInelasticCrossSection(const G4double S)
{
return GetTotalCrossSection(S) - GetElasticCrossSection(S);
}
//-------------------------Probabilities ----------------------------
G4double G4PomeronCrossSection::GetTotalProbability(const G4double S,
const G4double impactsquare)
{
return 2/pomeron_C*(1-G4Exp(-1*Eikonal(S,impactsquare)));
}
G4double G4PomeronCrossSection::GetDiffractiveProbability(const G4double S,
const G4double impactsquare)
{
return (pomeron_C-1)/pomeron_C *
(GetTotalProbability(S,impactsquare) -
GetNondiffractiveProbability(S,impactsquare));
}
G4double G4PomeronCrossSection::GetNondiffractiveProbability(const G4double S,
const G4double impactsquare)
{
return (1-G4Exp(-2*Eikonal(S,impactsquare)))/pomeron_C;
}
G4double G4PomeronCrossSection::GetElasticProbability(const G4double S,
const G4double impactsquare)
{
return (GetTotalProbability(S,impactsquare) -
GetInelasticProbability(S,impactsquare));
}
G4double G4PomeronCrossSection::GetInelasticProbability(const G4double S,
const G4double impactsquare)
{
return GetNondiffractiveProbability(S,impactsquare) +
GetDiffractiveProbability(S,impactsquare);
}
G4double G4PomeronCrossSection::GetCutPomeronProbability(const G4double S,
const G4double impactsquare, const G4int nPomerons)
{
G4double factorial=G4Pow::GetInstance()->factorial(nPomerons);
return G4Exp(-2*Eikonal(S,impactsquare))/pomeron_C*
G4Pow::GetInstance()->powN(2*Eikonal(S,impactsquare),nPomerons)/factorial;
}
// ---------------Temporary --- GF
void G4PomeronCrossSection::Setgamma(const G4double agam)
{
pomeron_Gamma=agam/GeV/GeV;
}
//----------------- private/Implementation methods
void G4PomeronCrossSection::InitForNucleon()
{
// pomeron_S= 3.0*GeV*GeV;
pomeron_S= 2.7*GeV*GeV;
// pomeron_Gamma= 2.16/GeV/GeV;
// pomeron_Gamma= 3.96/GeV/GeV;
pomeron_Gamma= (2.6+3.96)/GeV/GeV;
pomeron_C= 1.4;
pomeron_Rsquare= 3.56/GeV/GeV;
// pomeron_Alpha= 1.0808;
pomeron_Alpha= 0.9808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV; // Note! if pomeron_Gamma_Hard != 0 to fit total pp-crosscection
// pomeron_Gamma_Soft shold be 2.35/GeV/GeV
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForPion()
{
pomeron_S= 1.5*GeV*GeV;
// pomeron_Gamma= 1.46/GeV/GeV;
pomeron_Gamma= 2.17/GeV/GeV;
pomeron_C= 1.6;
pomeron_Rsquare= 2.36/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForKaon()
{
pomeron_S= 2.3*GeV*GeV;
// pomeron_Gamma= 1.31/GeV/GeV;
pomeron_Gamma= 1.92/GeV/GeV;
pomeron_C= 1.8;
pomeron_Rsquare= 1.96/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForGamma()
{
pomeron_S= 1.7*GeV*GeV;
// pomeron_Gamma= 1.42/GeV/GeV;
pomeron_Gamma= 2.07/GeV/GeV;
pomeron_C= 1.7;
pomeron_Rsquare= 2.16/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
G4double G4PomeronCrossSection::Expand(G4double z)
{
G4double sum=1.;
G4double current=1.;
for (G4int j=2; j<21; j++ )
{
current *= -z *(j-1)/sqr(j);
sum+=current;
}
return sum;
}
G4double G4PomeronCrossSection::Power(const G4double S)
{
return pomeron_Gamma * G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha -1);
}
G4double G4PomeronCrossSection::Z(const G4double S)
{
return 2*pomeron_C * Power(S) / Lambda(S);
}
G4double G4PomeronCrossSection::Lambda(const G4double S)
{
return pomeron_Rsquare+pomeron_Alphaprime*G4Log(S/pomeron_S);
}
G4double G4PomeronCrossSection::SigP(const G4double S)
{
return 8 * pi * hbarc_squared * Power(S);
}
G4double G4PomeronCrossSection::Eikonal(const G4double S,
const G4double impactsquare)
{
return Z(S)/2 * G4Exp(-impactsquare/(4*Lambda(S)*hbarc_squared));
}
//*************************************************************************************************
G4double G4PomeronCrossSection::PowerSoft(const G4double S)
{
return pomeron_Gamma * G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha -1);
}
G4double G4PomeronCrossSection::PowerHard(const G4double S)
{
return pomeron_Gamma_Hard*G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha_Hard -1);
}
G4double G4PomeronCrossSection::LambdaSoft(const G4double S)
{
return pomeron_Rsquare+pomeron_Alphaprime*G4Log(S/pomeron_S);
}
G4double G4PomeronCrossSection::LambdaHard(const G4double /*S*/)
{
return pomeron_Rsquare; //+pomeron_Alphaprime*G4Log(s/pomeron_S);
}
G4double G4PomeronCrossSection::Zsoft(const G4double S)
{
return 2*pomeron_C*PowerHard(S) / LambdaSoft(S);
}
G4double G4PomeronCrossSection::Zhard(const G4double S)
{
return 2*pomeron_C*PowerHard(S)/LambdaHard(S);
}
G4double G4PomeronCrossSection::SoftEikonal(G4double S, G4double impactsquare)
{
return Zsoft(S)/2*G4Exp(-impactsquare/LambdaSoft(S)/hbarc_squared/4);
}
G4double G4PomeronCrossSection::HardEikonal(G4double S, G4double impactsquare)
{
return Zhard(S)/2*G4Exp(-impactsquare/LambdaHard(S)/hbarc_squared/4);
}
//*************************************************************************************************
source/processes/hadronic/models/pre_equilibrium/exciton_model/include/G4PreCompoundFragmentVector.icc
-37
View File
@@ -1,37 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4PreCompoundFragmentVector.icc 68028 2013-03-13 13:48:15Z gcosmo $
//
// Hadronic Process: Nuclear Preequilibrium
// by V. Lara
//
// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
// cross section option
// JMQ (06 September 2008) Also external choice has been added for:
// - superimposed Coulomb barrier (if useSICB=true)
source/processes/hadronic/models/radioactive_decay/include/G4AlphaDecayChannel.hh
-85
View File
@@ -1,85 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4AlphaDecayChannel_h
#define G4AlphaDecayChannel_h 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULE: G4AlphaDecayChannel.hh
//
// Version: 0.b.3
// Date: 29/02/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
////////////////////////////////////////////////////////////////////////////////
//
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4AlphaDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Alpha decay proceess.
//
// class description - end
public:
G4AlphaDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,
G4double theEndPointEnergy=0.0,
G4double theDaughterExcitation=0.0) :
G4NuclearDecayChannel (Alpha, Verbose, theParentNucleus, theBR,
theEndPointEnergy,
(theParentNucleus->GetBaryonNumber())-4,
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-2,
theDaughterExcitation, "alpha")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cout <<"G4AlphaDecayChannel constructor" << G4endl;
#endif
}
~G4AlphaDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4BetaMinusDecayChannel.hh
-92
View File
@@ -1,92 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4BetaMinusDecayChannel_h
#define G4BetaMinusDecayChannel_h 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULE: G4BetaMinusDecayChannel.hh
//
// Version: 0.b.3
// Date: 29/02/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
////////////////////////////////////////////////////////////////////////////////
//
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "Randomize.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4BetaMinusDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Beta- decay proceess.
//
// class description - end
public:
G4BetaMinusDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,
G4double theEndPointEnergy=0.0,
G4double theDaughterExcitation=0.0,
G4double theFFN=1.0,
G4bool theBetaSimple = false,
G4RandGeneral* theRandEnergy = 0):
G4NuclearDecayChannel (BetaMinus, Verbose, theParentNucleus, theBR,
theFFN,
theBetaSimple,
theRandEnergy,
theEndPointEnergy,
theParentNucleus->GetBaryonNumber(),
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)+1,
theDaughterExcitation, "e-", "anti_nu_e")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cout <<"G4BetaMinusDecayChannel constructor" <<G4endl;
#endif
}
~G4BetaMinusDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4BetaPlusDecayChannel.hh
-99
View File
@@ -1,99 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4BetaPlusDecayChannel_h
#define G4BetaPlusDecayChannel_h 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULE: G4BetaPlusDecayChannel.hh
//
// Version: 0.b.3
// Date: 29/02/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
////////////////////////////////////////////////////////////////////////////////
//
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "Randomize.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4BetaPlusDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Beta+ decay proceess.
//
// class description - end
//
//
public:
G4BetaPlusDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,
G4double theEndPointEnergy=0.0,
G4double theDaughterExcitation=0.0,
G4double theFFN=0.0,
G4bool theBetaSimple = false,
G4RandGeneral* theRandEnergy = 0) :
G4NuclearDecayChannel (BetaPlus,
Verbose,
theParentNucleus,
theBR,
theFFN,
theBetaSimple,
theRandEnergy,
theEndPointEnergy,
theParentNucleus->GetBaryonNumber(),
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-1,
theDaughterExcitation, "e+", "nu_e")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cout <<"G4BetaPlusDecayChannel constructor" <<G4endl;
#endif
}
~G4BetaPlusDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4ITDecayChannel.hh
-57
View File
@@ -1,57 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4ITDecayChannel_h
#define G4ITDecayChannel_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
class G4ITDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Specific decay channel for isomeric transitions
//
// class description - end
public:
G4ITDecayChannel(G4int Verbose, const G4Ions* theParentNucleus,
G4double theBR)
: G4NuclearDecayChannel(IT, Verbose, theParentNucleus, theBR, 0.0,
theParentNucleus->GetBaryonNumber(),
G4int(theParentNucleus->GetPDGCharge()/CLHEP::eplus),
theParentNucleus->GetExcitationEnergy())
{
#ifdef G4VERBOSE
if (GetVerboseLevel() > 1)
G4cout << "G4ITDecayChannel constructor" << G4endl;
#endif
}
~G4ITDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4KshellECDecayChannel.hh
-85
View File
@@ -1,85 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4KshellECDecayChannel_h
#define G4KshellECDecayChannel_h 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULE: G4KshellECDecayChannel.hh
//
// Version: 0.b.3
// Date: 29/02/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
////////////////////////////////////////////////////////////////////////////////
//
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4KshellECDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Electron Capture proceess with electron from the K shell
//
// class description - end
public:
G4KshellECDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,
G4double theQtransit=0.0,
G4double theDaughterExcitation=0.0) :
G4NuclearDecayChannel (KshellEC, Verbose, theParentNucleus, theBR,
theQtransit, theParentNucleus->GetBaryonNumber(),
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-1,
theDaughterExcitation, "nu_e")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cout <<"G4KshellECDecayChannel constructor" << G4endl;
#endif
}
~G4KshellECDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4LshellECDecayChannel.hh
-64
View File
@@ -1,64 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4LshellECDecayChannel_h
#define G4LshellECDecayChannel_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4LshellECDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Electron Capture proceess with electron from the L shell
//
// class description - end
public:
G4LshellECDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,G4double theQtransit=0.0,
G4double theDaughterExcitation=0.0) :
G4NuclearDecayChannel (LshellEC, Verbose, theParentNucleus, theBR,
theQtransit, theParentNucleus->GetBaryonNumber(),
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-1,
theDaughterExcitation,
"nu_e")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cerr <<"G4LshellECDecayChannel constructor" << G4endl;
#endif
}
~G4LshellECDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4MshellECDecayChannel.hh
-64
View File
@@ -1,64 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4MshellECDecayChannel_h
#define G4MshellECDecayChannel_h 1
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4MshellECDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Electron Capture proceess with electron from the M shell
//
// class description - end
public:
G4MshellECDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,G4double theQtransit=0.0,
G4double theDaughterExcitation=0.0) :
G4NuclearDecayChannel (MshellEC, Verbose, theParentNucleus, theBR,
theQtransit, theParentNucleus->GetBaryonNumber(),
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-1,
theDaughterExcitation,
"nu_e")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cerr <<"G4MshellECDecayChannel constructor" << G4endl;
#endif
}
~G4MshellECDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4NuclearDecayChannel.hh
-160
View File
@@ -1,160 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4NuclearDecayChannel_h
#define G4NuclearDecayChannel_h 1
#include "globals.hh"
#include "G4VDecayChannel.hh"
#include "G4Ions.hh"
#include "G4IonTable.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTable.hh"
#include "G4GeneralPhaseSpaceDecay.hh"
#include "G4RadioactiveDecayMode.hh"
#include "Randomize.hh"
class G4NuclearDecayChannel : public G4GeneralPhaseSpaceDecay
{
// class description
//
// G4NuclearDecayChannel is a derived class from G4GeneralPhaseSpaceDecay,
// itself a derived class from G4VDecayChannel. It provides the required
// decay channels for all nuclear decay modes and through the DecayIt()
// member function returns the decay products.
//
// class description - end
public: // with description
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode, G4int Verbose)
: G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode),Qtransition(0) {;}
// default constructor
// Decay channel ctor with one decay product
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode, G4int Verbose,
const G4ParticleDefinition* theParentNucleus,
const G4double theBR,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation);
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode, G4int Verbose,
const G4ParticleDefinition* theParentNucleus,
G4double theBR,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation,
const G4String theDaughterName1);
// constructor decay channel with two decay products
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode, G4int Verbose,
const G4ParticleDefinition* theParentNucleus,
G4double theBR, G4double theFFN,
G4bool betaS, G4RandGeneral* randBeta,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation,
const G4String theDaughterName1,
const G4String theDaughterName2);
// constructor decay channel with three decay product
virtual ~G4NuclearDecayChannel();
// Returns the decay products
G4DecayProducts* DecayIt(G4double);
// Set the half-life threshold for isomer production
void SetHLThreshold(G4double hl) {halflifethreshold = hl;}
// Enable/disable ICM
void SetICM(G4bool icm) {applyICM = icm;}
// Enable/disable ARM
void SetARM (G4bool arm) {applyARM = arm;}
inline G4RadioactiveDecayMode GetDecayMode () {return decayMode;}
// Returns the decay mode
inline G4double GetDaughterExcitation () {return daughterExcitation;}
// Returns the excitaion energy of the daughter nuclide
inline G4ParticleDefinition* GetDaughterNucleus () {return daughterNucleus;}
// Returns the daughter nuclide.
private:
G4NuclearDecayChannel(const G4String& theName, const G4String& theParentName,
G4double theBR, G4int theNumberOfDaughters,
const G4String theDaughterName1,
const G4String theDaughterName2,
const G4String theDaughterName3,
const G4String theDaughterName4);
G4NuclearDecayChannel(const G4String& theParentName,
G4double theBR, G4int theNumberOfDaughters,
const G4String& theDaughterName1,
const G4String& theDaughterName2 = "",
const G4String& theDaughterName3 = "");
G4NuclearDecayChannel(const G4String& theParentName,
G4double theParentMass, G4double theBR,
G4int theNumberOfDaughters,
const G4String& theDaughterName1,
const G4String& theDaughterName2 = "",
const G4String& theDaughterName3 = "");
void FillDaughterNucleus(G4int index, G4int A, G4int Z,
const G4double theDaughterExcitation);
G4DecayProducts* BetaDecayIt();
// to replace the ThreeBodyDecayIt() to generate the correct beta spectrum
// Add copy and assignment prototypes even though no dynamic allocation
// of class members
G4NuclearDecayChannel(const G4NuclearDecayChannel &right);
G4NuclearDecayChannel& operator=(const G4NuclearDecayChannel &right);
protected:
//Data members marked with G4ThreadLocal are not invariant among threads
//Need to make them TLS
const G4RadioactiveDecayMode decayMode;
static const G4double pTolerance;
static const G4double levelTolerance;
G4double daughterExcitation;
G4int daughterA;
G4int daughterZ;
G4ParticleDefinition* daughterNucleus;
static G4ThreadLocal G4DynamicParticle* dynamicDaughter;
const G4double Qtransition;
G4double halflifethreshold;
G4bool applyICM;
G4bool applyARM;
G4RandGeneral* RandomEnergy; // not dynamically allocated
};
#endif
source/processes/hadronic/models/radioactive_decay/include/G4ProtonDecayChannel.hh
-90
View File
@@ -1,90 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4ProtonDecayChannel_h
#define G4ProtonDecayChannel_h 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULE: G4ProtonDecayChannel.hh
// Author: L.G. Sarmiento
//
// Based almost one to one on G4AlphaDecayChannel
//
// Version: 0.b.3
// Date: 29/02/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 28 July 2014, Created by L.G. Sarmiento based almost one to one on
// G4AlphaDecayChannel
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
////////////////////////////////////////////////////////////////////////////////
//
#include <CLHEP/Units/SystemOfUnits.h>
#include "globals.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4RadioactiveDecayMode.hh"
////////////////////////////////////////////////////////////////////////////////
//
class G4ProtonDecayChannel : public G4NuclearDecayChannel
{
// class description
//
// Derived class from G4NuclearDecayChannel. It is specific for
// Proton decay proceess. Based on the Alpha decay process.
//
// class description - end
public:
G4ProtonDecayChannel (G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
G4double theBR,
G4double theEndPointEnergy=0.0,
G4double theDaughterExcitation=0.0) :
G4NuclearDecayChannel (Proton, Verbose, theParentNucleus, theBR,
theEndPointEnergy,
(theParentNucleus->GetBaryonNumber())-1,
int(theParentNucleus->GetPDGCharge()/CLHEP::eplus)-1,
theDaughterExcitation, "proton")
{
#ifdef G4VERBOSE
if (GetVerboseLevel()>1)
G4cout <<"G4ProtonDecayChannel constructor" << G4endl;
#endif
}
~G4ProtonDecayChannel () {;}
};
#endif
source/processes/hadronic/models/radioactive_decay/src/G4NuclearDecayChannel.cc
-627
View File
@@ -1,627 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// MODULES: G4NuclearDecayChannel.cc
//
// Version: 0.b.4
// Date: 14/04/00
// Author: F Lei & P R Truscott
// Organisation: DERA UK
// Customer: ESA/ESTEC, NOORDWIJK
// Contract: 12115/96/JG/NL Work Order No. 3
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
// CHANGE HISTORY
// --------------
//
// 29 February 2000, P R Truscott, DERA UK
// 0.b.3 release.
//
// 18 October 2002, F Lei
// modified link metheds in DecayIt() to G4PhotoEvaporation() in order to
// use the new Internal Coversion feature.
// 13 April 2000, F Lei, DERA UK
// Changes made are:
// 1) Use PhotonEvaporation instead of DiscreteGammaDeexcitation
// 2) verbose control
//
// 17 October 2011, L. Desorgher
// -Allow the atomic relaxation after de-excitation of exited
// nuclei even for beta and alpha
// decay. Bug found and solution proposed by Ko Abe.
// -Set halflifethreshold by default to a negative value
//
// 20 November 2011, V.Ivanchenko
// - Migration to new design of atomic deexcitation
//
///////////////////////////////////////////////////////////////////////////////
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4NuclearLevelManager.hh"
#include "G4NuclearLevelStore.hh"
#include "G4NuclearDecayChannel.hh"
#include "G4DynamicParticle.hh"
#include "G4DecayProducts.hh"
#include "G4DecayTable.hh"
#include "G4PhysicsLogVector.hh"
#include "G4ParticleChangeForRadDecay.hh"
#include "G4IonTable.hh"
#include "G4PhotonEvaporation.hh"
#include "G4VAtomDeexcitation.hh"
#include "G4AtomicShells.hh"
#include "G4LossTableManager.hh"
//Model const parameters
const G4double G4NuclearDecayChannel:: pTolerance = 0.001;
const G4double G4NuclearDecayChannel:: levelTolerance = 2.0*keV;
//const G4bool G4NuclearDecayChannel:: FermiOn = true;
//This is a kind of "cache"
G4ThreadLocal G4DynamicParticle* G4NuclearDecayChannel::dynamicDaughter = 0;
// Constructor for one decay product (the nucleus)
G4NuclearDecayChannel::
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode,
G4int Verbose,
const G4ParticleDefinition* theParentNucleus,
const G4double theBR,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation)
:G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode),
Qtransition(theQtransition), RandomEnergy(0)
{
#ifdef G4VERBOSE
if (GetVerboseLevel() > 1) {
G4cout << "G4NuclearDecayChannel constructor for " << G4int(theMode)
<< G4endl;
}
#endif
SetParent(theParentNucleus);
CheckAndFillParent();
G4MT_parent_mass = theParentNucleus->GetPDGMass();
SetBR(theBR);
SetNumberOfDaughters (1);
FillDaughterNucleus(0, A, Z, theDaughterExcitation);
halflifethreshold = nanosecond;
applyICM = true;
applyARM = true;
CheckAndFillDaughters();
}
// Constructor for a daughter nucleus and one other particle.
//
G4NuclearDecayChannel::
G4NuclearDecayChannel(const G4RadioactiveDecayMode& theMode,
G4int Verbose,
const G4ParticleDefinition* theParentNucleus,
const G4double theBR,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation,
const G4String theDaughterName1)
:G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode),
Qtransition(theQtransition), RandomEnergy(0)
{
#ifdef G4VERBOSE
if (GetVerboseLevel() > 1) {
G4cout << "G4NuclearDecayChannel constructor for " << G4int(theMode)
<< G4endl;
}
#endif
SetParent(theParentNucleus);
CheckAndFillParent();
G4MT_parent_mass = theParentNucleus->GetPDGMass();
SetBR(theBR);
SetNumberOfDaughters (2);
SetDaughter(0, theDaughterName1);
FillDaughterNucleus(1, A, Z, theDaughterExcitation);
halflifethreshold = nanosecond;
applyICM = true;
applyARM = true;
CheckAndFillDaughters();
}
// Constructor for a daughter nucleus and two other particles
//
G4NuclearDecayChannel::
G4NuclearDecayChannel(const G4RadioactiveDecayMode &theMode,
G4int Verbose,
const G4ParticleDefinition *theParentNucleus,
const G4double theBR,
G4double /* theFFN */,
G4bool /* betaS */,
G4RandGeneral* randBeta,
const G4double theQtransition,
const G4int A, const G4int Z,
const G4double theDaughterExcitation,
const G4String theDaughterName1,
const G4String theDaughterName2)
:G4GeneralPhaseSpaceDecay(Verbose), decayMode(theMode),
Qtransition(theQtransition)
{
#ifdef G4VERBOSE
if (GetVerboseLevel() > 1) {
G4cout << "G4NuclearDecayChannel constructor for " << G4int(theMode)
<< G4endl;
}
#endif
SetParent(theParentNucleus);
CheckAndFillParent();
G4MT_parent_mass = theParentNucleus->GetPDGMass();
SetBR (theBR);
SetNumberOfDaughters (3);
SetDaughter(0, theDaughterName1);
SetDaughter(2, theDaughterName2);
FillDaughterNucleus(1, A, Z, theDaughterExcitation);
RandomEnergy = randBeta;
halflifethreshold = nanosecond;
applyICM = true;
applyARM = true;
CheckAndFillDaughters();
}
G4NuclearDecayChannel::~G4NuclearDecayChannel()
{}
void G4NuclearDecayChannel::FillDaughterNucleus(G4int index, G4int A, G4int Z,
const G4double theDaughterExcitation)
{
// Determine if the proposed daughter nucleus has a sensible A, Z and
// excitation energy.
if (A < 1 || Z < 0 || theDaughterExcitation < 0.0) {
G4ExceptionDescription ed;
ed << "Inappropriate values of daughter A, Z or excitation: "
<< A << " , " << Z << " , " << theDaughterExcitation*MeV << " MeV "
<< G4endl;
G4Exception("G4NuclearDecayChannel::FillDaughterNucleus()", "HAD_RDM_006",
FatalException, ed);
}
// Save A and Z to local variables. Find the GROUND STATE of the daughter
// nucleus and save this, as an ion, in the array of daughters.
daughterA = A;
daughterZ = Z;
if (Z == 1 && A == 1) {
daughterNucleus = G4Proton::Definition();
} else if (Z == 0 && A == 1) {
daughterNucleus = G4Neutron::Definition();
} else {
G4IonTable *theIonTable =
(G4IonTable*)(G4ParticleTable::GetParticleTable()->GetIonTable());
// GetIon with only Z and A arguments returns ground state
daughterNucleus = theIonTable->GetIon(daughterZ, daughterA);
}
daughterExcitation = theDaughterExcitation;
SetDaughter(index, daughterNucleus);
}
G4DecayProducts* G4NuclearDecayChannel::DecayIt(G4double)
{
G4double deltaM;
if (decayMode == 1) { // beta- decay
deltaM = CLHEP::electron_mass_c2;
} else if (decayMode == 2) { // beta+ decay
deltaM = 2.*CLHEP::electron_mass_c2;
} else if (decayMode < 6 && decayMode > 2) { // EC
deltaM = -CLHEP::electron_mass_c2;
} else { // all others
deltaM = 0.0;
}
// Mass available for decay in rest frame of parent after correcting for
// the appropriate number of electron masses and reserving the daughter
// excitation energy to be applied later
G4double massOfParent = G4MT_parent->GetPDGMass(); // PDG mass includes excitation energy
SetParentMass(massOfParent - deltaM - daughterExcitation);
// Define a product vector.
G4DecayProducts* products = 0;
// Depending upon the number of daughters, select the appropriate decay
// kinematics scheme.
switch (numberOfDaughters) {
case 0:
{
G4ExceptionDescription ed;
ed << " No daughters defined " << G4endl;
G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_005",
JustWarning, ed);
}
break;
case 1:
products = OneBodyDecayIt();
break;
case 2:
products = TwoBodyDecayIt();
break;
case 3:
products = BetaDecayIt();
break;
default:
{
G4ExceptionDescription ed;
ed << " More than 3 daughters in decay: N = " << numberOfDaughters
<< G4endl;
G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_007",
FatalException, ed);
}
}
if (products == 0) {
G4ExceptionDescription ed;
ed << " Parent nucleus " << *parent_name << " was not decayed " << G4endl;
G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_008",
JustWarning, ed);
DumpInfo();
} else {
// If the decay is to an excited state of the daughter nuclide, the photon
// evaporation process must be applied.
// Need to hold the shell idex after ICM
G4int shellIndex = -1;
if (daughterExcitation > 0.0) {
// Pop the daughter nucleus off the product vector to get its 4-momentum
dynamicDaughter = products->PopProducts();
G4LorentzVector daughterMomentum = dynamicDaughter->Get4Momentum();
if (dynamicDaughter) delete dynamicDaughter;
// Using daughter nucleus, set up a G4Fragment for photon evaporatation
if (decayMode == 0) {
G4double exe = ((const G4Ions*)(G4MT_parent))->GetExcitationEnergy();
daughterMomentum.setE(daughterMomentum.e() + exe);
}
G4Fragment nucleus(daughterA, daughterZ, daughterMomentum);
G4PhotonEvaporation* deexcitation = new G4PhotonEvaporation;
deexcitation->SetVerboseLevel(GetVerboseLevel());
// switch on/off internal electron conversion
deexcitation->SetICM(applyICM);
// In IT mode, we need to force the transition
if (decayMode == 0) {
deexcitation->RDMForced(true);
// at this point, de-excitation will occur even if IT state is long-lived (>1ns)
// Why does it need to be forced?
} else {
// Not forced, but decay will still happen if lifetime < 1 ns,
// otherwise no gamma decay is performed
deexcitation->RDMForced(false);
}
//////////////////////////////////////////////////////////////////////////
// //
// Apply photon evaporation if Isomeric Transition is indicated. //
// Use G4PhotonEvaporation::BreakUp() which does only one transition. //
// This allows IC to be done. //
// //
//////////////////////////////////////////////////////////////////////////
G4IonTable* theIonTable =
(G4IonTable*)(G4ParticleTable::GetParticleTable()->GetIonTable());
G4ParticleDefinition* daughterIon = 0;
if (decayMode != 0) {
daughterIon = theIonTable->GetIon(daughterZ, daughterA, daughterExcitation);
} else {
// The fragment vector from photon evaporation contains the list of
// evaporated gammas, some of which may have been replaced by conversion
// electrons. The last element is the residual nucleus.
// Note: try photoEvapProducts as a name instead of gammas
G4FragmentVector* gammas = deexcitation->BreakUp(nucleus);
G4int nFrags = G4int(gammas->size());
G4double eOrGammaEnergy = 0.0;
if (nFrags < 1) {
G4ExceptionDescription ed;
ed << nFrags << " No fragments produced by photon evaporation. " << G4endl;
G4Exception("G4NuclearDecayChannel::DecayIt()","HAD_RDM_012",
FatalException, ed);
} else if (nFrags > 1) {
// Add gamma/e- to the decay product. The angular distribution of this
// particle is assumed to be isotropic
G4Fragment* eOrGamma;
G4DynamicParticle* eOrGammaDyn;
for (G4int i = 0; i < nFrags - 1; i++) {
eOrGamma = gammas->operator[](i);
eOrGammaDyn = new G4DynamicParticle(eOrGamma->GetParticleDefinition(),
eOrGamma->GetMomentum() );
eOrGammaDyn->SetProperTime(eOrGamma->GetCreationTime() );
products->PushProducts(eOrGammaDyn);
eOrGammaEnergy += eOrGamma->GetMomentum().e();
}
}
G4double finalDaughterExcitation =
gammas->operator[](nFrags-1)->GetExcitationEnergy();
if (finalDaughterExcitation <= 1.0*keV) finalDaughterExcitation = 0;
// Get new ion with excitation energy reduced by emitted gamma energy
daughterIon =
theIonTable->GetIon(daughterZ, daughterA, finalDaughterExcitation);
daughterMomentum.setE(daughterMomentum.e() - eOrGammaEnergy);
// Delete/reset variables associated with the gammas.
while (!gammas->empty() ) { /* Loop checking, 01.09.2015, D.Wright */
delete *(gammas->end()-1);
gammas->pop_back();
}
delete gammas;
} // end if decayMode == 0
G4ThreeVector const daughterMomentum1(static_cast<const G4LorentzVector> (daughterMomentum));
dynamicDaughter = new G4DynamicParticle(daughterIon, daughterMomentum1);
products->PushProducts(dynamicDaughter);
// retrieve the ICM shell index
shellIndex = deexcitation->GetVacantShellNumber();
delete deexcitation;
} // if daughter excitation > 0
// Now take care of the EC products which have to go through the ARM
G4int eShell = -1;
if (decayMode == 3 || decayMode == 4 || decayMode == 5) {
switch (decayMode)
{
case KshellEC:
{
eShell = 0; // --> 0 from 1 (f.lei 30/4/2008)
}
break;
case LshellEC:
{
eShell = G4int(G4UniformRand()*3)+1;
}
break;
case MshellEC:
{
// limit the shell index to 6 as specified by the ARM (F.Lei 06/05/2010)
// eShell = G4int(G4UniformRand()*5)+4;
eShell = G4int(G4UniformRand()*3)+4;
}
break;
case RDM_ERROR:
default:
G4Exception("G4NuclearDecayChannel::DecayIt()", "HAD_RDM_009",
FatalException, "Incorrect decay mode selection");
}
} else {
// For other cases eShell comes from shellIndex resulting from the photo decay
// modeled by G4PhotonEvaporation* de-excitation (see above)
eShell = shellIndex;
}
// now apply ARM if it is requested and there is a vaccancy
if (applyARM && eShell != -1) {
G4int aZ = daughterZ;
// V.Ivanchenko migration to new interface to atomic deexcitation
// no check on index of G4MaterialCutsCouple, simplified
// check on secondary energy Esec < 0.1 keV
G4VAtomDeexcitation* atomDeex =
G4LossTableManager::Instance()->AtomDeexcitation();
if (atomDeex) {
if(atomDeex->IsFluoActive() && aZ > 5 && aZ < 100) { // only applies to 5< Z <100
if (eShell >= G4AtomicShells::GetNumberOfShells(aZ)){
eShell = G4AtomicShells::GetNumberOfShells(aZ)-1;
}
G4AtomicShellEnumerator as = G4AtomicShellEnumerator(eShell);
const G4AtomicShell* shell = atomDeex->GetAtomicShell(aZ, as);
std::vector<G4DynamicParticle*> armProducts;
// VI, SI
// Allows fixing of Bugzilla 1727
//const G4double deexLimit = 0.1*keV;
G4double deexLimit = 0.1*keV;
if (G4EmParameters::Instance()->DeexcitationIgnoreCut()) deexLimit =0.;
//
atomDeex->GenerateParticles(&armProducts, shell, aZ, deexLimit, deexLimit);
size_t narm = armProducts.size();
if (narm > 0) {
// L.Desorgher: need to initialize dynamicDaughter in some decay
// cases (for example Hg194)
dynamicDaughter = products->PopProducts();
G4ThreeVector bst = dynamicDaughter->Get4Momentum().boostVector();
for (size_t i = 0; i<narm; ++i) {
G4DynamicParticle* dp = armProducts[i];
G4LorentzVector lv = dp->Get4Momentum().boost(bst);
dp->Set4Momentum(lv);
products->PushProducts(dp);
}
products->PushProducts(dynamicDaughter);
}
}
}
}
} // Parent nucleus decayed
/*
if (atomDeex && aZ > 5 && aZ < 100) { // only applies to 5< Z <100
// Retrieve the corresponding identifier and binding energy of the selected shell
const G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
//check that eShell is smaller than the max number of shells
//this to avoid a warning from transitionManager(otherwise the output is the same)
//Correction to Bug 1662. L Desorgher (04/02/2011)
if (eShell >= transitionManager->NumberOfShells(aZ)){
eShell=transitionManager->NumberOfShells(aZ)-1;
}
const G4AtomicShell* shell = transitionManager->Shell(aZ, eShell);
G4double bindingEnergy = shell->BindingEnergy();
G4int shellId = shell->ShellId();
G4AtomicDeexcitation* atomDeex = new G4AtomicDeexcitation();
//the default is no Auger electron generation.
// Switch it on/off here!
atomDeex->ActivateAugerElectronProduction(true);
std::vector<G4DynamicParticle*>* armProducts = atomDeex->GenerateParticles(aZ,shellId);
// pop up the daughter before insertion;
// f.lei (30/04/2008) check if the total kinetic energy is less than
// the shell binding energy; if true add the difference to the daughter to conserve the energy
dynamicDaughter = products->PopProducts();
G4double tARMEnergy = 0.0;
for (size_t i = 0; i < armProducts->size(); i++) {
products->PushProducts ((*armProducts)[i]);
tARMEnergy += (*armProducts)[i]->GetKineticEnergy();
}
if ((bindingEnergy - tARMEnergy) > 0.1*keV){
G4double dEnergy = dynamicDaughter->GetKineticEnergy() + (bindingEnergy - tARMEnergy);
dynamicDaughter->SetKineticEnergy(dEnergy);
}
products->PushProducts(dynamicDaughter);
#ifdef G4VERBOSE
if (GetVerboseLevel()>0)
{
G4cout <<"G4NuclearDecayChannel::Selected shell number for ARM = " <<shellId <<G4endl;
G4cout <<"G4NuclearDecayChannel::ARM products = " <<armProducts->size()<<G4endl;
G4cout <<" The binding energy = " << bindingEnergy << G4endl;
G4cout <<" Total ARM particle kinetic energy = " << tARMEnergy << G4endl;
}
#endif
delete armProducts;
delete atomDeex;
}
}
*/
return products;
}
G4DecayProducts* G4NuclearDecayChannel::BetaDecayIt()
{
G4double pmass = GetParentMass();
G4double daughtermass[3];
for (G4int index = 0; index < 3; index++) {
daughtermass[index] = G4MT_daughters[index]->GetPDGMass();
}
// Add excitation energy so daughter can be decayed later
daughtermass[1] += daughterExcitation;
// Create parent G4DynamicParticle at rest and create products
G4ParticleMomentum dummy;
G4DynamicParticle parentParticle(G4MT_parent, dummy, 0.0);
G4DecayProducts* products = new G4DecayProducts(parentParticle);
// faster method as suggested by Dirk Kruecker of FZ-Julich
G4double daughtermomentum[3];
G4double daughterenergy[3];
// Use the histogram distribution to generate the beta energy
// 0 = electron, 1 = daughter, 2 = neutrino
daughterenergy[0] = Qtransition*RandomEnergy->shoot(G4Random::getTheEngine());
daughtermomentum[0] = std::sqrt(daughterenergy[0]*(daughterenergy[0] + 2.*daughtermass[0]) );
// neutrino energy distribution is flat within the kinematical limits
G4double rd = 2.*G4UniformRand() - 1.;
// limits
G4double Mme = daughtermass[1] + Qtransition;
G4double K = 0.5 - daughtermass[1]*daughtermass[1]/(2*Mme*Mme-4*pmass*daughterenergy[0]);
daughterenergy[2] = K * (Mme - daughterenergy[0] + rd*daughtermomentum[0]);
daughtermomentum[2] = daughterenergy[2];
// the recoil nucleus
daughterenergy[1] = Qtransition - daughterenergy[0] - daughterenergy[2];
G4double recoilmomentumsquared =
daughterenergy[1]*(daughterenergy[1] + 2.0*daughtermass[1]);
if (recoilmomentumsquared < 0.0) recoilmomentumsquared = 0.0;
daughtermomentum[1] = std::sqrt(recoilmomentumsquared);
// output message
if (GetVerboseLevel()>1) {
G4cout << " G4NuclearDecayChannel::BetaDecayIt() " << G4endl;
G4cout <<" e- momentum: " <<daughtermomentum[0]/GeV <<" [GeV/c]" <<G4endl;
G4cout <<" daughter momentum: " <<daughtermomentum[1]/GeV <<" [GeV/c]" <<G4endl;
G4cout <<" nu momentum: " <<daughtermomentum[2]/GeV <<" [GeV/c]" <<G4endl;
G4cout <<" e- energy: " << daughtermass[0] + daughterenergy[0] << G4endl;
G4cout <<" daughter energy: " << daughtermass[1] + daughterenergy[1] << G4endl;
G4cout <<" nu energy: " << daughtermass[2] + daughterenergy[2] << G4endl;
G4cout <<" total of daughter energies: " << daughtermass[0] + daughtermass[1] +
daughtermass[2] + daughterenergy[0] + daughterenergy[1] + daughterenergy[2]
<< G4endl;
}
//create daughter G4DynamicParticle
G4double costheta, sintheta, phi, sinphi, cosphi;
G4double costhetan, sinthetan, phin, sinphin, cosphin;
costheta = 2.*G4UniformRand()-1.0;
sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
phi = twopi*G4UniformRand()*rad;
sinphi = std::sin(phi);
cosphi = std::cos(phi);
// electron chosen isotropically
G4ParticleMomentum direction0(sintheta*cosphi,sintheta*sinphi,costheta);
G4DynamicParticle * daughterparticle
= new G4DynamicParticle( G4MT_daughters[0], direction0*daughtermomentum[0]);
products->PushProducts(daughterparticle);
// cos of angle between electron and neutrino
costhetan = (daughtermomentum[1]*daughtermomentum[1]-
daughtermomentum[2]*daughtermomentum[2]-
daughtermomentum[0]*daughtermomentum[0])/
(2.0*daughtermomentum[2]*daughtermomentum[0]);
if (costhetan > 1.) costhetan = 1.;
if (costhetan < -1.) costhetan = -1.;
sinthetan = std::sqrt((1.0-costhetan)*(1.0+costhetan));
phin = twopi*G4UniformRand()*rad;
sinphin = std::sin(phin);
cosphin = std::cos(phin);
G4ParticleMomentum direction2;
direction2.setX(sinthetan*cosphin*costheta*cosphi -
sinthetan*sinphin*sinphi + costhetan*sintheta*cosphi);
direction2.setY(sinthetan*cosphin*costheta*sinphi +
sinthetan*sinphin*cosphi + costhetan*sintheta*sinphi);
direction2.setZ(-sinthetan*cosphin*sintheta + costhetan*costheta);
daughterparticle = new G4DynamicParticle(G4MT_daughters[2],
direction2*(daughtermomentum[2]/direction2.mag()));
products->PushProducts(daughterparticle);
// daughter nucleus p = - (p_e + p_nu )
daughterparticle =
new G4DynamicParticle(G4MT_daughters[1],
(direction0*daughtermomentum[0] +
direction2*(daughtermomentum[2]/direction2.mag()))*(-1.0));
products->PushProducts(daughterparticle);
if (GetVerboseLevel()>1) {
G4cout << "G4NuclearDecayChannel::BetaDecayIt ";
G4cout << " create decay products in rest frame " <<G4endl;
products->DumpInfo();
}
return products;
}