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

Import Geant4 10.7.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-06-26 10:23:25 +02:00
parent c02c370437
commit 67ba86d073
1871 changed files with 174422 additions and 131884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/particles/management/include/G4VDecayChannel.hh
+174 -152
View File
@@ -23,19 +23,16 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4VDecayChannel
//
// Class description:
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
//
// History: first implementation, based on object model of
// 27 July 1996 H.Kurashige
// 30 May 1997 H.Kurashige
// 23 Mar. 2000 H.Weber : add GetAngularMomentum()
// ------------------------------------------------------------
#ifndef G4VDecayChannel_h
#define G4VDecayChannel_h 1
// Abstract class to describe decay kinematics
// Author: H.Kurashige, 27 July 1996
// --------------------------------------------------------------------
#ifndef G4VDecayChannel_hh
#define G4VDecayChannel_hh 1
#include <cmath>
@@ -45,156 +42,148 @@
#include "G4Threading.hh"
#include "G4AutoLock.hh"
class G4ParticleDefinition;
class G4DecayProducts;
class G4ParticleTable;
class G4ParticleDefinition;
class G4DecayProducts;
class G4ParticleTable;
class G4VDecayChannel
{
// Class Description:
//
// Abstract class to describe decay kinematics
public:
public: // with description
G4VDecayChannel(const G4String& aName, G4int Verbose = 1);
G4VDecayChannel(const G4String& aName,
const G4String& theParentName,
G4double theBR,
G4int theNumberOfDaughters,
const G4String& theDaughterName1,
const G4String& theDaughterName2 = "",
const G4String& theDaughterName3 = "",
const G4String& theDaughterName4 = "" );
// Constructors
// Constructors
G4VDecayChannel(const G4String &aName, G4int Verbose = 1);
G4VDecayChannel(const G4String &aName,
const G4String& theParentName,
G4double theBR,
G4int theNumberOfDaughters,
const G4String& theDaughterName1,
const G4String& theDaughterName2 = "",
const G4String& theDaughterName3 = "",
const G4String& theDaughterName4 = "" );
// Destructor
virtual ~G4VDecayChannel();
// Destructor
// equality operators
G4bool operator==(const G4VDecayChannel &right) const {return (this == &right);}
G4bool operator!=(const G4VDecayChannel &right) const {return (this != &right);}
G4bool operator==(const G4VDecayChannel& r) const { return (this == &r); }
G4bool operator!=(const G4VDecayChannel& r) const { return (this != &r); }
// Equality operators
// less-than operator is defined for G4DecayTable
G4bool operator<(const G4VDecayChannel &right) const;
inline G4bool operator<(const G4VDecayChannel& right) const;
// Less-than operator is defined for G4DecayTable
virtual G4DecayProducts* DecayIt(G4double parentMass = -1.0) = 0;
// get kinematics name
const G4String& GetKinematicsName() const;
// get branching ratio
G4double GetBR() const;
// get number of daughter particles
G4int GetNumberOfDaughters() const;
inline const G4String& GetKinematicsName() const;
// Get kinematics name
inline G4double GetBR() const;
// Get branching ratio
inline G4int GetNumberOfDaughters() const;
// Get number of daughter particles
// get the pointer to the parent particle
G4ParticleDefinition * GetParent();
// get the pointer to a daughter particle
G4ParticleDefinition * GetDaughter(G4int anIndex);
inline G4ParticleDefinition* GetParent();
// Get the pointer to the parent particle
inline G4ParticleDefinition* GetDaughter(G4int anIndex);
// Get the pointer to a daughter particle
// get the angular momentum of the decay
G4int GetAngularMomentum();
// get the name of the parent particle
const G4String& GetParentName() const;
//get the name of a daughter particle
const G4String& GetDaughterName(G4int anIndex) const;
// Get the angular momentum of the decay
inline const G4String& GetParentName() const;
// Get the name of the parent particle
inline const G4String& GetDaughterName(G4int anIndex) const;
// Get the name of a daughter particle
// get mass of parent
G4double GetParentMass() const;
G4double GetDaughterMass(G4int anIndex) const;
inline G4double GetParentMass() const;
// Get mass of parent
inline G4double GetDaughterMass(G4int anIndex) const;
// Get mass of daughter
// set the parent particle (by name or by pointer)
void SetParent(const G4ParticleDefinition * particle_type);
void SetParent(const G4String &particle_name);
// set branching ratio
inline void SetParent(const G4String &particle_name);
// Set the parent particle (by name or by pointer)
void SetBR(G4double value);
// set number of daughter particles
// Set branching ratio
void SetNumberOfDaughters(G4int value);
// set a daughter particle (by name or by pointer)
void SetDaughter(G4int anIndex,
const G4ParticleDefinition * particle_type);
void SetDaughter(G4int anIndex,
const G4String &particle_name);
// Set number of daughter particles
void SetDaughter(G4int anIndex, const G4ParticleDefinition* particle_type);
void SetDaughter(G4int anIndex, const G4String& particle_name);
// Set a daughter particle (by name or by pointer)
void SetVerboseLevel(G4int value);
G4int GetVerboseLevel() const;
void DumpInfo();
inline void SetVerboseLevel(G4int value);
inline G4int GetVerboseLevel() const;
void DumpInfo();
G4double GetRangeMass() const;
void SetRangeMass(G4double val);
virtual G4bool IsOKWithParentMass(G4double parentMass);
inline G4double GetRangeMass() const;
inline void SetRangeMass(G4double val);
virtual G4bool IsOKWithParentMass(G4double parentMass);
void SetPolarization(const G4ThreeVector&);
const G4ThreeVector& GetPolarization() const;
protected: // with description
// clear daughters array
void ClearDaughtersName();
void SetPolarization(const G4ThreeVector&);
inline const G4ThreeVector& GetPolarization() const;
protected:
void ClearDaughtersName();
// Clear daughters array
inline void CheckAndFillDaughters();
inline void CheckAndFillParent();
private:
// fill daughters array
void FillDaughters();
// fill parent
void FillParent();
G4double DynamicalMass(G4double massPDG, G4double width,
G4double maxDev = 1.0) const;
protected: // without description
// default constructor
G4VDecayChannel();
// Default constructor
// copy constructor and assignment operator
G4VDecayChannel(const G4VDecayChannel &);
G4VDecayChannel & operator=(const G4VDecayChannel &);
G4VDecayChannel(const G4VDecayChannel&);
G4VDecayChannel& operator=(const G4VDecayChannel&);
// Copy constructor and assignment operator
private:
void FillDaughters();
// Fill daughters array
void FillParent();
// Fill parent
const G4String& GetNoName() const;
protected:
G4double DynamicalMass(G4double massPDG, G4double width, G4double maxDev = +1.) const;
protected:
// kinematics name
G4String kinematics_name;
// branching ratio [0.0 - 1.0]
G4double rbranch;
// number of daughters
G4int numberOfDaughters;
// parent particle
G4String* parent_name;
// daughter particles
G4String** daughters_name;
G4String kinematics_name = "";
// Kinematics name
G4double rbranch = 0.0;
// Branching ratio [0.0 - 1.0]
G4String* parent_name = nullptr;
// Parent particle
G4String** daughters_name = nullptr;
// Daughter particles
// range of mass allowed in decay
G4double rangeMass;
G4double rangeMass = 2.5;
// Range of mass allowed in decay
// polarization of the parent particle
G4ThreeVector parent_polarization;
// Polarization of the parent particle
// pointer to particle table
G4ParticleTable* particletable;
// control flag for output message
G4int verboseLevel;
// 0: Silent
// 1: Warning message
// 2: More
G4ParticleTable* particletable = nullptr;
// Pointer to particle table
static const G4String noName;
G4ParticleDefinition* G4MT_parent;
G4ParticleDefinition** G4MT_daughters;
G4double G4MT_parent_mass;
G4double* G4MT_daughters_mass;
G4double* G4MT_daughters_width;
G4ParticleDefinition* G4MT_parent = nullptr;
G4ParticleDefinition** G4MT_daughters = nullptr;
G4double G4MT_parent_mass = 0.0;
G4double* G4MT_daughters_mass = nullptr;
G4double* G4MT_daughters_width = nullptr;
G4Mutex daughtersMutex;
G4Mutex parentMutex;
G4int numberOfDaughters = 0;
// Number of daughters
G4int verboseLevel = 1;
// Control flag for output message
// 0: Silent
// 1: Warning message
// 2: More
};
// ------------------------------------------------------------
@@ -202,34 +191,42 @@ class G4VDecayChannel
// ------------------------------------------------------------
inline
G4bool G4VDecayChannel::operator<(const G4VDecayChannel &right) const
G4bool G4VDecayChannel::operator<(const G4VDecayChannel& right) const
{
return (this->rbranch < right.rbranch);
}
inline
G4ParticleDefinition* G4VDecayChannel::GetDaughter(G4int anIndex)
{
G4ParticleDefinition* G4VDecayChannel::GetDaughter(G4int anIndex)
{
// pointers to daughter particles are filled, if they are not set yet
CheckAndFillDaughters();
// get the pointer to a daughter particle
if ( (anIndex>=0) && (anIndex<numberOfDaughters) ) {
if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
{
return G4MT_daughters[anIndex];
} else {
}
else
{
if (verboseLevel>0)
G4cout << "G4VDecayChannel::GetDaughter index out of range "<<anIndex<<G4endl;
return 0;
G4cout << "G4VDecayChannel::GetDaughter index out of range "
<< anIndex << G4endl;
return nullptr;
}
}
inline
const G4String& G4VDecayChannel::GetDaughterName(G4int anIndex) const
const G4String& G4VDecayChannel::GetDaughterName(G4int anIndex) const
{
if ( (anIndex>=0) && (anIndex<numberOfDaughters) ) {
if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
{
return *daughters_name[anIndex];
} else {
if (verboseLevel>0){
}
else
{
if (verboseLevel>0)
{
G4cout << "G4VDecayChannel::GetDaughterName ";
G4cout << "index out of range " << anIndex << G4endl;
}
@@ -238,12 +235,16 @@ inline
}
inline
G4double G4VDecayChannel::GetDaughterMass(G4int anIndex) const
G4double G4VDecayChannel::GetDaughterMass(G4int anIndex) const
{
if ( (anIndex>=0) && (anIndex<numberOfDaughters) ) {
if ( (anIndex>=0) && (anIndex<numberOfDaughters) )
{
return G4MT_daughters_mass[anIndex];
} else {
if (verboseLevel>0){
}
else
{
if (verboseLevel>0)
{
G4cout << "G4VDecayChannel::GetDaughterMass ";
G4cout << "index out of range " << anIndex << G4endl;
}
@@ -252,7 +253,7 @@ inline
}
inline
G4ParticleDefinition* G4VDecayChannel::GetParent()
G4ParticleDefinition* G4VDecayChannel::GetParent()
{
// the pointer to the parent particle is filled, if it is not set yet
CheckAndFillParent();
@@ -261,75 +262,96 @@ inline
}
inline
const G4String& G4VDecayChannel::GetParentName() const
const G4String& G4VDecayChannel::GetParentName() const
{
return *parent_name;
}
inline
G4double G4VDecayChannel::GetParentMass() const
G4double G4VDecayChannel::GetParentMass() const
{
return G4MT_parent_mass;
}
inline
void G4VDecayChannel::SetParent(const G4String &particle_name)
void G4VDecayChannel::SetParent(const G4String& particle_name)
{
if (parent_name != 0) delete parent_name;
if (parent_name != nullptr) delete parent_name;
parent_name = new G4String(particle_name);
G4MT_parent = 0;
G4MT_parent = nullptr;
}
inline
G4int G4VDecayChannel::GetNumberOfDaughters() const
G4int G4VDecayChannel::GetNumberOfDaughters() const
{
return numberOfDaughters;
}
inline
const G4String& G4VDecayChannel::GetKinematicsName() const { return kinematics_name; }
const G4String& G4VDecayChannel::GetKinematicsName() const
{
return kinematics_name;
}
inline
G4double G4VDecayChannel::GetBR() const { return rbranch; }
G4double G4VDecayChannel::GetBR() const
{
return rbranch;
}
inline
void G4VDecayChannel::SetVerboseLevel(G4int value){ verboseLevel = value; }
void G4VDecayChannel::SetVerboseLevel(G4int value)
{
verboseLevel = value;
}
inline
G4int G4VDecayChannel::GetVerboseLevel() const { return verboseLevel; }
G4int G4VDecayChannel::GetVerboseLevel() const
{
return verboseLevel;
}
inline
G4double G4VDecayChannel::GetRangeMass() const { return rangeMass; }
G4double G4VDecayChannel::GetRangeMass() const
{
return rangeMass;
}
inline
void G4VDecayChannel::SetRangeMass(G4double val){ if(val>=0.) rangeMass=val; }
inline
void G4VDecayChannel::SetPolarization(const G4ThreeVector& polar)
void G4VDecayChannel::SetPolarization(const G4ThreeVector& polar)
{
parent_polarization = polar;
}
inline
const G4ThreeVector& G4VDecayChannel::GetPolarization() const
const G4ThreeVector& G4VDecayChannel::GetPolarization() const
{
return parent_polarization;
}
inline
void G4VDecayChannel::CheckAndFillDaughters() {
void G4VDecayChannel::CheckAndFillDaughters()
{
G4AutoLock l(&daughtersMutex);
if ( G4MT_daughters ==0 ) {
l.unlock();
FillDaughters();
if ( G4MT_daughters == nullptr )
{
l.unlock();
FillDaughters();
}
}
inline void G4VDecayChannel::CheckAndFillParent() {
inline
void G4VDecayChannel::CheckAndFillParent()
{
G4AutoLock l(&parentMutex);
if ( G4MT_parent == 0 ) {
l.unlock();
FillParent();
if ( G4MT_parent == nullptr )
{
l.unlock();
FillParent();
}
}
#endif