Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4MolecularConfiguration Class Reference

#include <G4MolecularConfiguration.hh>

Classes

class  G4MolecularConfigurationManager
 

Public Types

using G4DiffCoeffParam = std::function<double (const G4Material *, double, const G4MolecularConfiguration *)>
 

Public Member Functions

void AddDiffCoeffParameterization (const G4DiffCoeffParam &)
 
const G4MoleculeDefinitionGetDefinition () const
 
const G4StringGetName () const
 
const G4StringGetFormatedName () const
 
G4int GetAtomsNumber () const
 
G4MolecularConfigurationExciteMolecule (G4int) const
 
G4MolecularConfigurationIonizeMolecule (G4int) const
 
G4MolecularConfigurationAddElectron (G4int orbit, G4int n=1) const
 
G4MolecularConfigurationRemoveElectron (G4int, G4int number=1) const
 
G4MolecularConfigurationMoveOneElectron (G4int, G4int) const
 
G4double GetNbElectrons () const
 
void PrintState () const
 
const std::vector< const G4MolecularDissociationChannel * > * GetDissociationChannels () const
 
G4int GetFakeParticleID () const
 
G4int GetMoleculeID () const
 
void SetDiffusionCoefficient (G4double)
 
G4double GetDiffusionCoefficient () const
 
G4double GetDiffusionCoefficient (const G4Material *, double temperature) const
 
void SetDecayTime (G4double)
 
G4double GetDecayTime () const
 
void SetVanDerVaalsRadius (G4double)
 
G4double GetVanDerVaalsRadius () const
 
const G4ElectronOccupancyGetElectronOccupancy () const
 
G4int GetCharge () const
 
void SetMass (G4double)
 
G4double GetMass () const
 
void SetLabel (const G4String &)
 
const G4StringGetLabel () const
 
void Finalize ()
 
void UnFinalize ()
 
void SetUserID (const G4String &userID)
 
const G4StringGetUserID () const
 
void Serialize (std::ostream &)
 
void Unserialize (std::istream &)
 

Static Public Member Functions

static G4MolecularConfigurationGetOrCreateMolecularConfiguration (const G4MoleculeDefinition *)
 
static G4MolecularConfigurationGetOrCreateMolecularConfiguration (const G4MoleculeDefinition *, const G4ElectronOccupancy &eOcc)
 
static G4MolecularConfigurationGetOrCreateMolecularConfiguration (const G4MoleculeDefinition *, int charge)
 
static G4MolecularConfigurationCreateMolecularConfiguration (const G4String &userIdentifier, const G4MoleculeDefinition *, bool &wasAlreadyCreated)
 
static G4MolecularConfigurationCreateMolecularConfiguration (const G4String &userIdentifier, const G4MoleculeDefinition *, const G4String &label, const G4ElectronOccupancy &eOcc, bool &wasAlreadyCreated)
 
static G4MolecularConfigurationCreateMolecularConfiguration (const G4String &userIdentifier, const G4MoleculeDefinition *, int charge, const G4String &label, bool &wasAlreadyCreated)
 
static G4MolecularConfigurationCreateMolecularConfiguration (const G4String &userIdentifier, const G4MoleculeDefinition *, const G4String &label, bool &wasAlreadyCreated)
 
static G4MolecularConfigurationGetMolecularConfiguration (const G4MoleculeDefinition *, const G4String &label)
 
static G4MolecularConfigurationGetMolecularConfiguration (int moleculeID)
 
static G4MolecularConfigurationGetMolecularConfiguration (const G4String &userID)
 
static int GetNumberOfSpecies ()
 
static std::map< G4String, G4MolecularConfiguration * > & GetUserIDTable ()
 
static void DeleteManager ()
 
static double DiffCoeffWater (double temperature_K)
 
static void FinalizeAll ()
 
static void PrintAll ()
 
static void SetGlobalTemperature (G4double)
 
static G4double GetGlobalTemperature ()
 
static G4MolecularConfigurationLoad (std::istream &)
 

Protected Member Functions

 G4MolecularConfiguration (const G4MoleculeDefinition *, const G4ElectronOccupancy &, const G4String &label="")
 
 G4MolecularConfiguration (const G4MoleculeDefinition *, int charge)
 
 G4MolecularConfiguration (const G4MoleculeDefinition *, const G4String &label, int charge)
 
 G4MolecularConfiguration (std::istream &)
 
 G4MolecularConfiguration (const G4MolecularConfiguration &)
 
G4MolecularConfigurationoperator= (G4MolecularConfiguration &right)
 
 ~G4MolecularConfiguration ()
 
G4MolecularConfigurationChangeConfiguration (const G4ElectronOccupancy &newElectronOccupancy) const
 
G4MolecularConfigurationChangeConfiguration (int charge) const
 
void CheckElectronOccupancy (const char *line) const
 
void MakeExceptionIfFinalized ()
 
void CreateDefaultDiffCoeffParam ()
 

Static Protected Member Functions

static void ScaleAllDiffusionCoefficientsOnWater (double temperature_K)
 
static G4MolecularConfigurationManagerGetManager ()
 
static double ReturnDefaultDiffCoeff (const G4Material *, double, const G4MolecularConfiguration *molConf)
 

Protected Attributes

const G4MoleculeDefinitionfMoleculeDefinition
 
const G4ElectronOccupancyfElectronOccupancy
 
G4StringfLabel
 
G4double fDynDiffusionCoefficient
 
G4double fDynVanDerVaalsRadius
 
G4double fDynDecayTime
 
G4double fDynMass
 
G4int fDynCharge
 
G4int fMoleculeID
 
G4String fFormatedName
 
G4String fName
 
G4String fUserIdentifier
 
G4bool fIsFinalized
 
G4DiffCoeffParam fDiffParam
 

Static Protected Attributes

static G4MolecularConfigurationManagerfgManager = nullptr
 
static double fgTemperature = 298
 

Detailed Description

The pointer G4MolecularConfiguration will be shared by all the molecules having the same molecule definition and the same electron occupancy BE CAREFUlL !!! : If you change the mass for instance of a OH^-, this will affect all the OH^- molecule diffusing around

Definition at line 97 of file G4MolecularConfiguration.hh.

Member Typedef Documentation

◆ G4DiffCoeffParam

using G4MolecularConfiguration::G4DiffCoeffParam = std::function<double (const G4Material *, double, const G4MolecularConfiguration *)>

Definition at line 101 of file G4MolecularConfiguration.hh.

Constructor & Destructor Documentation

◆ G4MolecularConfiguration() [1/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MoleculeDefinition * moleculeDef,
const G4ElectronOccupancy & elecOcc,
const G4String & label = "" )
protected

Definition at line 417 of file G4MolecularConfiguration.cc.

421{
422 fMoleculeDefinition = moleculeDef;
423
424 fMoleculeID = GetManager()->Insert(moleculeDef,
425 elecOcc,
426 this);
428 elecOcc);
429
430 /*
431 fgManager->fTable[fMoleculeDefinition][elecOcc] = this;
432 std::map<G4ElectronOccupancy, G4MolecularConfiguration*, comparator>::iterator it ;
433 it = fgManager->fTable[moleculeDef].find(elecOcc);
434 fElectronOccupancy = &(it->first);
435 */
436
439 + moleculeDef->GetCharge();
441
445
447 fName += "^";
449
451 fFormatedName += "^";
452 fFormatedName += "{";
454 fFormatedName += "}";
455
456 fLabel = nullptr; // let it here
457
458 if(!label.empty())
459 {
460 SetLabel(label);
461 }
462
464
465 fIsFinalized = false;
466}
const G4ElectronOccupancy * FindCommonElectronOccupancy(const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)
G4int Insert(const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc, G4MolecularConfiguration *molConf)
static G4MolecularConfigurationManager * GetManager()
const G4ElectronOccupancy * fElectronOccupancy
static double ReturnDefaultDiffCoeff(const G4Material *, double, const G4MolecularConfiguration *molConf)
const G4MoleculeDefinition * fMoleculeDefinition
const G4String & GetName() const
const G4String & GetFormatedName() const
G4double GetVanDerVaalsRadius() const
G4double GetDiffusionCoefficient() const
static G4String ConvertToString(G4bool boolVal)

Referenced by ChangeConfiguration(), ChangeConfiguration(), CreateMolecularConfiguration(), CreateMolecularConfiguration(), CreateMolecularConfiguration(), CreateMolecularConfiguration(), G4MolecularConfiguration::G4MolecularConfigurationManager::GetOrCreateMolecularConfiguration(), G4MolecularConfiguration::G4MolecularConfigurationManager::GetOrCreateMolecularConfiguration(), GetOrCreateMolecularConfiguration(), GetOrCreateMolecularConfiguration(), and Load().

◆ G4MolecularConfiguration() [2/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MoleculeDefinition * moleculeDef,
int charge )
protected

◆ G4MolecularConfiguration() [3/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MoleculeDefinition * moleculeDef,
const G4String & label,
int charge )
protected

◆ G4MolecularConfiguration() [4/5]

G4MolecularConfiguration::G4MolecularConfiguration ( std::istream & in)
protected

Definition at line 1393 of file G4MolecularConfiguration.cc.

1394{
1395 fLabel = nullptr; // TODO: for now not serialized
1396 Unserialize(in);
1397 fMoleculeDefinition = nullptr;
1398 fElectronOccupancy = nullptr;
1399 if(fElectronOccupancy != nullptr)
1400 {
1405
1406 if(fLabel != nullptr)
1407 {
1409 }
1410 }
1411 else if(fLabel != nullptr)
1412 {
1414 }
1415 else if(fDynCharge != 0)
1416 {
1418 }
1419}
void RecordNewlyLabeledConfiguration(G4MolecularConfiguration *molConf)

◆ G4MolecularConfiguration() [5/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MolecularConfiguration & )
protected

◆ ~G4MolecularConfiguration()

G4MolecularConfiguration::~G4MolecularConfiguration ( )
protected

Definition at line 507 of file G4MolecularConfiguration.cc.

508{
510
511// if (G4AllocatorList::GetAllocatorListIfExist())
512// {
513// if (fElectronOccupancy)
514// {
515// delete fElectronOccupancy;
516// fElectronOccupancy = 0;
517// }
518// }
519}
static G4MolecularConfigurationManager * fgManager

Member Function Documentation

◆ AddDiffCoeffParameterization()

void G4MolecularConfiguration::AddDiffCoeffParameterization ( const G4DiffCoeffParam & para)
inline

Definition at line 572 of file G4MolecularConfiguration.hh.

574{
575 fDiffParam = para;
576}

◆ AddElectron()

G4MolecularConfiguration * G4MolecularConfiguration::AddElectron ( G4int orbit,
G4int n = 1 ) const

Add n electrons to a given orbit. Note : You can add as many electrons to a given orbit, the result may be unrealist.

Definition at line 616 of file G4MolecularConfiguration.cc.

618{
619// MakeExceptionIfFinalized();
620 CheckElectronOccupancy(__func__);
621 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
622 newElectronOccupancy.AddElectron(orbit, number);
623 return ChangeConfiguration(newElectronOccupancy);
624}
G4MolecularConfiguration * ChangeConfiguration(const G4ElectronOccupancy &newElectronOccupancy) const
void CheckElectronOccupancy(const char *line) const

Referenced by G4Molecule::AddElectron().

◆ ChangeConfiguration() [1/2]

G4MolecularConfiguration * G4MolecularConfiguration::ChangeConfiguration ( const G4ElectronOccupancy & newElectronOccupancy) const
protected

Definition at line 524 of file G4MolecularConfiguration.cc.

526{
529 newElectronOccupancy);
530
531 if (output == nullptr)
532 {
534 newElectronOccupancy);
535 }
536 return output;
537}
G4MolecularConfiguration * GetMolecularConfiguration(const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)
G4MolecularConfiguration(const G4MoleculeDefinition *, const G4ElectronOccupancy &, const G4String &label="")

Referenced by AddElectron(), ExciteMolecule(), IonizeMolecule(), MoveOneElectron(), and RemoveElectron().

◆ ChangeConfiguration() [2/2]

G4MolecularConfiguration * G4MolecularConfiguration::ChangeConfiguration ( int charge) const
protected

Definition at line 542 of file G4MolecularConfiguration.cc.

543{
546
547 if (output == nullptr)
548 {
549 output = new G4MolecularConfiguration(fMoleculeDefinition, charge);
550 }
551 return output;
552}

◆ CheckElectronOccupancy()

void G4MolecularConfiguration::CheckElectronOccupancy ( const char * line) const
protected

Definition at line 788 of file G4MolecularConfiguration.cc.

789{
790 if (fElectronOccupancy == nullptr)
791 {
792 G4String functionName(function);
793 G4ExceptionDescription description;
794 description
795 << "No G4ElectronOccupancy was defined for molecule definition : "
797 << ". The definition was probably defined using the charge state, "
798 "rather than electron state.";
799
800 G4Exception(functionName, "", FatalErrorInArgument, description);
801 }
802}
G4double(*)(G4double) function
@ FatalErrorInArgument
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
std::ostringstream G4ExceptionDescription

Referenced by AddElectron(), ExciteMolecule(), GetNbElectrons(), IonizeMolecule(), MoveOneElectron(), and RemoveElectron().

◆ CreateDefaultDiffCoeffParam()

void G4MolecularConfiguration::CreateDefaultDiffCoeffParam ( )
protected

Definition at line 1465 of file G4MolecularConfiguration.cc.

1466{
1467 if(!static_cast<bool>(fDiffParam))
1468 {
1470 }
1471}

Referenced by Finalize().

◆ CreateMolecularConfiguration() [1/4]

G4MolecularConfiguration * G4MolecularConfiguration::CreateMolecularConfiguration ( const G4String & userIdentifier,
const G4MoleculeDefinition * molDef,
bool & wasAlreadyCreated )
static

Definition at line 1059 of file G4MolecularConfiguration.cc.

1063{
1064 wasAlreadyCreated = false;
1065 G4MolecularConfiguration* preRegisteredMolConf =
1066 GetManager()->GetMolecularConfiguration(userIdentifier);
1067
1068 if(preRegisteredMolConf != nullptr)
1069 {
1070 if(preRegisteredMolConf->GetDefinition() == molDef)
1071 {
1072 wasAlreadyCreated = true;
1073 return preRegisteredMolConf;
1074 }
1075 }
1076
1077 if(molDef->GetGroundStateElectronOccupancy() != nullptr)
1078 {
1079 const G4ElectronOccupancy& elecOcc = *molDef
1081 G4MolecularConfiguration* molConf =
1082 GetManager()->GetMolecularConfiguration(molDef, elecOcc);
1083
1084 if(molConf != nullptr)
1085 {
1086 if(molConf->fUserIdentifier.empty())
1087 {
1088 molConf->fUserIdentifier = userIdentifier;
1089 }
1090 else if(molConf->fUserIdentifier != userIdentifier)
1091 {
1093 errMsg << "A molecular configuration for the definition named "
1094 << molDef->GetName() << " has already been created "
1095 "and recorded with a different user ID "
1096 << molConf->fUserIdentifier;
1097 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1098 "DOUBLE_CREATION",
1100 errMsg);
1101 }
1102// TODO exception
1104 errMsg << "A molecular configuration for the definition named "
1105 << molDef->GetName() << " has already been created.";
1106 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1107 "DOUBLE_CREATION",
1109 errMsg);
1110 wasAlreadyCreated = true;
1111 return molConf;
1112 }
1113
1114 // G4cout << "Create molConf for " << molDef->GetName() << G4endl;
1115 auto newConf = new G4MolecularConfiguration(molDef,
1116 elecOcc);
1117 newConf->fUserIdentifier = userIdentifier;
1118
1119 GetManager()->AddUserID(userIdentifier, newConf);
1120
1121// G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
1122// newConf);
1123 return newConf;
1124 }
1125
1126 return CreateMolecularConfiguration(userIdentifier,
1127 molDef,
1128 molDef->GetName(),
1129 molDef->GetCharge(),
1130 wasAlreadyCreated);
1131}
@ JustWarning
void AddUserID(const G4String &name, G4MolecularConfiguration *molecule)
const G4MoleculeDefinition * GetDefinition() const
static G4MolecularConfiguration * CreateMolecularConfiguration(const G4String &userIdentifier, const G4MoleculeDefinition *, bool &wasAlreadyCreated)
const G4ElectronOccupancy * GetGroundStateElectronOccupancy() const

Referenced by G4MoleculeTable::CreateConfiguration(), G4MoleculeTable::CreateConfiguration(), G4MoleculeTable::CreateConfiguration(), G4MoleculeTable::CreateConfiguration(), CreateMolecularConfiguration(), G4MoleculeDefinition::NewConfiguration(), G4MoleculeDefinition::NewConfigurationWithElectronOccupancy(), and G4MoleculeTableMessenger::SetNewValue().

◆ CreateMolecularConfiguration() [2/4]

G4MolecularConfiguration * G4MolecularConfiguration::CreateMolecularConfiguration ( const G4String & userIdentifier,
const G4MoleculeDefinition * molDef,
const G4String & label,
bool & wasAlreadyCreated )
static

Definition at line 1136 of file G4MolecularConfiguration.cc.

1141{
1142 assert(label != "");
1143 wasAlreadyCreated = false;
1144
1145 G4MolecularConfiguration* molConf =
1146 GetManager()->GetMolecularConfiguration(molDef, label);
1147 if(molConf != nullptr)
1148 {
1149 if((molConf->fLabel != nullptr)
1150 && *molConf->fLabel == label)
1151 {
1152 wasAlreadyCreated = true;
1153 return molConf;
1154 }
1155 if(molConf->fLabel == nullptr)
1156 {
1157 wasAlreadyCreated = true;
1158 molConf->SetLabel(label);
1159 return molConf;
1160 }
1161 if(molConf->fLabel->empty())
1162 {
1163 wasAlreadyCreated = true;
1164 molConf->SetLabel(label);
1165 return molConf;
1166 }
1167
1168 molConf->PrintState();
1169 G4ExceptionDescription errMsg ;
1170 errMsg << "A molecular configuration for the definition named "
1171 << molDef->GetName()
1172 << " has already been created "
1173 "with user ID "
1174 << molConf->fUserIdentifier << " and label "
1175 << molConf->GetLabel();
1176 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1177 "DOUBLE_CREATION",
1179 errMsg);
1180 // KILL APP
1181 }
1182 else
1183 {
1184 auto newConf =
1185 new G4MolecularConfiguration(molDef,
1186 label,
1187 molDef->GetCharge());
1188 newConf->fUserIdentifier = userIdentifier;
1189
1190 GetManager()->AddUserID(userIdentifier, newConf);
1191
1192// G4MoleculeTable::Instance()->
1193// RecordMolecularConfiguration(userIdentifier, newConf);
1194 return newConf;
1195 }
1196 return molConf;
1197}
const G4String & GetLabel() const

◆ CreateMolecularConfiguration() [3/4]

G4MolecularConfiguration * G4MolecularConfiguration::CreateMolecularConfiguration ( const G4String & userIdentifier,
const G4MoleculeDefinition * molDef,
const G4String & label,
const G4ElectronOccupancy & eOcc,
bool & wasAlreadyCreated )
static

Definition at line 1202 of file G4MolecularConfiguration.cc.

1208{
1209 assert(label != "");
1210 wasAlreadyCreated = false;
1211
1212 G4MolecularConfiguration* molConf =
1213 GetManager()->GetMolecularConfiguration(molDef, eOcc);
1214
1215 if(molConf != nullptr)
1216 {
1217 if(molConf->GetElectronOccupancy() != nullptr)
1218 {
1219 if(*molConf->GetElectronOccupancy() == eOcc)
1220 {
1221 if((molConf->fLabel != nullptr) && *molConf->fLabel == label)
1222 {
1223 wasAlreadyCreated = true;
1224 return molConf;
1225 }
1226 if(molConf->fLabel == nullptr)
1227 {
1228 wasAlreadyCreated = true;
1229 molConf->SetLabel(label);
1230 return molConf;
1231 }
1232 if(molConf->fLabel->empty())
1233 {
1234 wasAlreadyCreated = true;
1235 molConf->SetLabel(label);
1236 return molConf;
1237 }
1238 }
1239 }
1240
1241
1242 molConf->PrintState();
1243 G4ExceptionDescription errMsg ;
1244 errMsg << "A molecular configuration for the definition named "
1245 << molDef->GetName()
1246 << " has already been created "
1247 "with user ID "
1248 << molConf->fUserIdentifier
1249 << " and possible different electronic state";
1250 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1251 "DOUBLE_CREATION",
1253 errMsg);
1254 }
1255 else
1256 {
1257 auto newConf =
1258 new G4MolecularConfiguration(molDef,
1259 eOcc,
1260 label);
1261 newConf->fUserIdentifier = userIdentifier;
1262
1263 GetManager()->AddUserID(userIdentifier, newConf);
1264
1265// G4MoleculeTable::Instance()->
1266// RecordMolecularConfiguration(userIdentifier, newConf);
1267 return newConf;
1268 }
1269 return molConf;
1270}
const G4ElectronOccupancy * GetElectronOccupancy() const

◆ CreateMolecularConfiguration() [4/4]

G4MolecularConfiguration * G4MolecularConfiguration::CreateMolecularConfiguration ( const G4String & userIdentifier,
const G4MoleculeDefinition * molDef,
int charge,
const G4String & label,
bool & wasAlreadyCreated )
static

Definition at line 969 of file G4MolecularConfiguration.cc.

974{
975 wasAlreadyCreated = false;
976 G4MolecularConfiguration* molConf =
977 GetManager()->GetMolecularConfiguration(molDef, charge);
978
979 if (molConf != nullptr)
980 {
981 if(molConf->fLabel == nullptr)
982 {
983 molConf->SetLabel(label);
985 wMsg << "The molecular configuration for the definition named "
986 << molDef->GetName()
987 << " with charge " << charge << " has already been created "
988 "but with NO label";
989 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
990 "DOUBLE_CREATION",
992 wMsg);
993 }
994 else if(molConf->fLabel->empty() )
995 {
996 molConf->SetLabel(label);
997 }
998 else if(*(molConf->fLabel) != label)
999 {
1000 G4ExceptionDescription errMsg ;
1001 errMsg << "The molecular configuration for the definition named "
1002 << molDef->GetName()
1003 << " with charge " << charge << " has already been created "
1004 "but with a different label :"
1005 << molConf->GetLabel();
1006 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1007 "DOUBLE_CREATION",
1009 errMsg);
1010 // KILL APP
1011 }
1012
1013 if(molConf->fUserIdentifier.empty())
1014 {
1015 molConf->fUserIdentifier = userIdentifier;
1016
1018 wMsg << "The molecular configuration for the definition named "
1019 << molDef->GetName()
1020 << " with label " << label << " has already been created.";
1021 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1022 "DOUBLE_CREATION",
1024 wMsg);
1025 }
1026 else if(molConf->fUserIdentifier != userIdentifier)
1027 {
1028 G4ExceptionDescription errMsg ;
1029 errMsg << "The molecular configuration for the definition named "
1030 << molDef->GetName()
1031 << " with label " << label << " has already been created "
1032 "BUT with a different user ID :"
1033 << molConf->fUserIdentifier;
1034 G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
1035 "DOUBLE_CREATION",
1037 errMsg);
1038 // KILL APP
1039 }
1040
1041 wasAlreadyCreated = true;
1042 return molConf;
1043 }
1044
1045 auto newConf =
1046 new G4MolecularConfiguration(molDef, label, charge);
1047 newConf->fUserIdentifier = userIdentifier;
1048
1049 GetManager()->AddUserID(userIdentifier, newConf);
1050
1051// G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
1052// newConf);
1053 return newConf;
1054}

◆ DeleteManager()

void G4MolecularConfiguration::DeleteManager ( )
static

◆ DiffCoeffWater()

double G4MolecularConfiguration::DiffCoeffWater ( double temperature_K)
static

Definition at line 1432 of file G4MolecularConfiguration.cc.

1433{
1434 return pow(10, 4.311
1435 - 2.722e3/temperature_K
1436 + 8.565e5/(temperature_K *temperature_K)
1437 - 1.181e8/(temperature_K*temperature_K*temperature_K ))*1e-9*m2/s;
1438}

Referenced by ScaleAllDiffusionCoefficientsOnWater(), and G4DNAMolecularReactionData::ScaledParameterization().

◆ ExciteMolecule()

G4MolecularConfiguration * G4MolecularConfiguration::ExciteMolecule ( G4int ExcitedLevel) const

Method used in Geant4-DNA to excite water molecules

Definition at line 568 of file G4MolecularConfiguration.cc.

569{
570// MakeExceptionIfFinalized();
571 CheckElectronOccupancy(__func__);
572 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
573
574 newElectronOccupancy.RemoveElectron(ExcitedLevel, 1);
575 newElectronOccupancy.AddElectron(5, 1);
576
577 return ChangeConfiguration(newElectronOccupancy);
578}

Referenced by G4Molecule::ExciteMolecule().

◆ Finalize()

void G4MolecularConfiguration::Finalize ( )
inline

Definition at line 561 of file G4MolecularConfiguration.hh.

◆ FinalizeAll()

void G4MolecularConfiguration::FinalizeAll ( )
static

Definition at line 1511 of file G4MolecularConfiguration.cc.

1512{
1513 const std::vector<G4MolecularConfiguration*>& species =
1515
1516 for(auto specie : species)
1517 {
1518 specie->Finalize();
1519 }
1520
1521}
const std::vector< G4MolecularConfiguration * > & GetAllSpecies()

Referenced by G4MoleculeTable::Finalize().

◆ GetAtomsNumber()

G4int G4MolecularConfiguration::GetAtomsNumber ( ) const

Returns the nomber of atoms compouning the molecule

Definition at line 701 of file G4MolecularConfiguration.cc.

702{
704}

Referenced by G4Molecule::GetAtomsNumber().

◆ GetCharge()

G4int G4MolecularConfiguration::GetCharge ( ) const
inline

Returns the charge of molecule.

Definition at line 518 of file G4MolecularConfiguration.hh.

519{
520 return fDynCharge;
521}

Referenced by G4DNAMolecularReactionData::ComputeEffectiveRadius(), and G4Molecule::GetCharge().

◆ GetDecayTime()

G4double G4MolecularConfiguration::GetDecayTime ( ) const
inline

Returns the decay time of the molecule.

Definition at line 502 of file G4MolecularConfiguration.hh.

503{
504 return fDynDecayTime;
505}

Referenced by G4Molecule::GetDecayTime().

◆ GetDefinition()

◆ GetDiffusionCoefficient() [1/2]

◆ GetDiffusionCoefficient() [2/2]

G4double G4MolecularConfiguration::GetDiffusionCoefficient ( const G4Material * material,
double temperature ) const
inline

Definition at line 579 of file G4MolecularConfiguration.hh.

581{
582 return fDiffParam(material, temperature, this);
583}

◆ GetDissociationChannels()

const vector< const G4MolecularDissociationChannel * > * G4MolecularConfiguration::GetDissociationChannels ( ) const

Definition at line 754 of file G4MolecularConfiguration.cc.

755{
756 // if (fElectronOccupancy == 0) return 0;
758}
const std::vector< const G4MolecularDissociationChannel * > * GetDecayChannels(const G4MolecularConfiguration *) const

Referenced by G4Molecule::GetDissociationChannels().

◆ GetElectronOccupancy()

const G4ElectronOccupancy * G4MolecularConfiguration::GetElectronOccupancy ( ) const
inline

Returns the object ElectronOccupancy describing the electronic configuration of the molecule.

Definition at line 480 of file G4MolecularConfiguration.hh.

481{
482 return fElectronOccupancy;
483}

Referenced by CreateMolecularConfiguration(), G4Molecule::GetElectronOccupancy(), and G4MolecularConfiguration::G4MolecularConfigurationManager::RemoveMolecularConfigurationFromTable().

◆ GetFakeParticleID()

G4int G4MolecularConfiguration::GetFakeParticleID ( ) const

Definition at line 762 of file G4MolecularConfiguration.cc.

763{
765 G4Exception("G4MolecularConfiguration::GetMoleculeID",
766 "",
768 "You should first enter a molecule definition");
769
770 return INT_MAX;
771}
#define INT_MAX
Definition templates.hh:90

Referenced by G4Molecule::GetFakeParticleID().

◆ GetFormatedName()

const G4String & G4MolecularConfiguration::GetFormatedName ( ) const

Returns the formated name of the molecule

Definition at line 694 of file G4MolecularConfiguration.cc.

695{
696 return fFormatedName;
697}

Referenced by G4Molecule::GetFormatedName().

◆ GetGlobalTemperature()

G4double G4MolecularConfiguration::GetGlobalTemperature ( )
static

◆ GetLabel()

const G4String & G4MolecularConfiguration::GetLabel ( ) const
inline

Definition at line 553 of file G4MolecularConfiguration.hh.

554{
555 if(fLabel == nullptr)
556 fLabel = new G4String();
557
558 return (*fLabel);
559}

Referenced by CreateMolecularConfiguration(), CreateMolecularConfiguration(), G4Molecule::GetLabel(), and PrintState().

◆ GetManager()

◆ GetMass()

G4double G4MolecularConfiguration::GetMass ( ) const
inline

Returns the total mass of the molecule.

Definition at line 529 of file G4MolecularConfiguration.hh.

530{
531 return fDynMass;
532}

Referenced by G4Molecule::GetDiffusionVelocity(), G4Molecule::GetKineticEnergy(), and G4Molecule::GetMass().

◆ GetMolecularConfiguration() [1/3]

◆ GetMolecularConfiguration() [2/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration ( const G4String & userID)
static

Definition at line 1504 of file G4MolecularConfiguration.cc.

1505{
1506 return GetManager()->GetMolecularConfiguration(userID);
1507}

◆ GetMolecularConfiguration() [3/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration ( int moleculeID)
static

Definition at line 961 of file G4MolecularConfiguration.cc.

962{
963 return GetManager()->GetMolecularConfiguration(moleculeID);
964}

◆ GetMoleculeID()

G4int G4MolecularConfiguration::GetMoleculeID ( ) const
inline

◆ GetName()

◆ GetNbElectrons()

G4double G4MolecularConfiguration::GetNbElectrons ( ) const

Returns the number of electron.

Definition at line 708 of file G4MolecularConfiguration.cc.

709{
710 CheckElectronOccupancy(__func__);
712}

Referenced by G4Molecule::GetNbElectrons().

◆ GetNumberOfSpecies()

int G4MolecularConfiguration::GetNumberOfSpecies ( )
static

◆ GetOrCreateMolecularConfiguration() [1/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetOrCreateMolecularConfiguration ( const G4MoleculeDefinition * molDef)
static

Definition at line 326 of file G4MolecularConfiguration.cc.

328{
329 if (molDef->GetGroundStateElectronOccupancy() != nullptr)
330 {
331 const G4ElectronOccupancy& elecOcc =
333 G4MolecularConfiguration* molConf =
334 GetManager()->GetMolecularConfiguration(molDef, elecOcc);
335
336 if (molConf != nullptr)
337 {
338 return molConf;
339 }
340
341 auto newConf =
342 new G4MolecularConfiguration(molDef,
343 elecOcc);
344 newConf->SetUserID(molDef->GetName());
345 return newConf;
346 }
347
348 G4MolecularConfiguration* molConf =
349 GetManager()->GetMolecularConfiguration(molDef, molDef->GetCharge());
350 if(molConf != nullptr)
351 {
352 return molConf;
353 }
354
355 auto newConf =
356 new G4MolecularConfiguration(molDef, molDef->GetCharge());
357 newConf->SetUserID(molDef->GetName());
358 return newConf;
359}

Referenced by G4Molecule::G4Molecule(), G4Molecule::G4Molecule(), G4Molecule::G4Molecule(), G4Molecule::G4Molecule(), G4MoleculeTable::PrepareMolecularConfiguration(), G4Molecule::SetElectronOccupancy(), and G4MoleculeTableMessenger::SetNewValue().

◆ GetOrCreateMolecularConfiguration() [2/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetOrCreateMolecularConfiguration ( const G4MoleculeDefinition * molDef,
const G4ElectronOccupancy & eOcc )
static

Definition at line 364 of file G4MolecularConfiguration.cc.

367{
368 return GetManager()->GetOrCreateMolecularConfiguration(molDef, elecOcc);
369
370// G4MolecularConfiguration* molConf =
371// GetManager()->GetMolecularConfiguration(molDef, elecOcc);
372//
373// if (molConf)
374// {
375// return molConf;
376// }
377// else
378// {
379// G4MolecularConfiguration* newConf =
380// new G4MolecularConfiguration(molDef, elecOcc);
381// return newConf;
382// }
383}
G4MolecularConfiguration * GetOrCreateMolecularConfiguration(const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)

◆ GetOrCreateMolecularConfiguration() [3/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetOrCreateMolecularConfiguration ( const G4MoleculeDefinition * molDef,
int charge )
static

Definition at line 388 of file G4MolecularConfiguration.cc.

391{
392 G4MolecularConfiguration* molConf =
393 GetManager()->GetMolecularConfiguration(molDef, charge);
394
395 if(molConf != nullptr)
396 {
397 return molConf;
398 }
399
400 auto newConf =
401 new G4MolecularConfiguration(molDef, charge);
402 return newConf;
403}

◆ GetUserID()

const G4String & G4MolecularConfiguration::GetUserID ( ) const
inline

Definition at line 567 of file G4MolecularConfiguration.hh.

568{
569 return fUserIdentifier;
570}

◆ GetUserIDTable()

static std::map< G4String, G4MolecularConfiguration * > & G4MolecularConfiguration::GetUserIDTable ( )
inlinestatic

Definition at line 166 of file G4MolecularConfiguration.hh.

167 {
168 return GetManager()->GetUserIDTable();
169 }
std::map< G4String, G4MolecularConfiguration * > & GetUserIDTable()

Referenced by G4MoleculeTable::GetConfigurationIterator().

◆ GetVanDerVaalsRadius()

G4double G4MolecularConfiguration::GetVanDerVaalsRadius ( ) const
inline

◆ IonizeMolecule()

G4MolecularConfiguration * G4MolecularConfiguration::IonizeMolecule ( G4int IonizedLevel) const

Method used in Geant4-DNA to ionize water molecules

Definition at line 585 of file G4MolecularConfiguration.cc.

586{
587// MakeExceptionIfFinalized();
588 CheckElectronOccupancy(__func__);
589 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
590
591 if (newElectronOccupancy.GetOccupancy(IonizedLevel) != 0)
592 {
593 newElectronOccupancy.RemoveElectron(IonizedLevel, 1);
594 }
595 else
596 {
597 G4String errMsg = "There is no electron on the orbit "
598 + G4UIcommand::ConvertToString(IonizedLevel)
599 + " you want to free. The molecule's name you want to ionized is "
600 + GetName();
601 G4Exception("G4MolecularConfiguration::IonizeMolecule",
602 "",
604 errMsg);
605 PrintState();
606 }
607
608 // DEBUG
609 // PrintState();
610
611 return ChangeConfiguration(newElectronOccupancy);
612}
const G4String & GetName() const

Referenced by G4Molecule::IonizeMolecule().

◆ Load()

G4MolecularConfiguration * G4MolecularConfiguration::Load ( std::istream & in)
static

Definition at line 1386 of file G4MolecularConfiguration.cc.

1387{
1388 return new G4MolecularConfiguration(in);
1389}

◆ MakeExceptionIfFinalized()

void G4MolecularConfiguration::MakeExceptionIfFinalized ( )
protected

Definition at line 113 of file G4MolecularConfiguration.cc.

114{
115 if(fIsFinalized)
116 {
118 errMsg << "This molecular configuration " << GetName()
119 << " is already finalized. Therefore its "
120 " properties cannot be changed.";
121 G4Exception("G4MolecularConfiguration::MakeExceptionIfFinalized",
122 "CONF_FINALIZED",FatalException,errMsg);
123 }
124}
@ FatalException

Referenced by SetDecayTime(), SetDiffusionCoefficient(), SetMass(), and SetVanDerVaalsRadius().

◆ MoveOneElectron()

G4MolecularConfiguration * G4MolecularConfiguration::MoveOneElectron ( G4int orbitToFree,
G4int orbitToFill ) const

Move one electron from an orbit to another.

Definition at line 658 of file G4MolecularConfiguration.cc.

660{
661// MakeExceptionIfFinalized();
662 CheckElectronOccupancy(__func__);
663 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
664
665 if (newElectronOccupancy.GetOccupancy(orbitToFree) >= 1)
666 {
667 newElectronOccupancy.RemoveElectron(orbitToFree, 1);
668 newElectronOccupancy.AddElectron(orbitToFill, 1);
669 }
670 else
671 {
672 G4String errMsg = "There is no electron on the orbit "
673 + G4UIcommand::ConvertToString(orbitToFree)
674 + " you want to free. The molecule's name is " + GetName();
675 G4Exception("G4MolecularConfiguration::MoveOneElectron",
676 "",
678 errMsg);
679 PrintState();
680 }
681
682 return ChangeConfiguration(newElectronOccupancy);
683}

Referenced by G4Molecule::MoveOneElectron().

◆ operator=()

G4MolecularConfiguration & G4MolecularConfiguration::operator= ( G4MolecularConfiguration & right)
protected

Definition at line 557 of file G4MolecularConfiguration.cc.

558{
559// if (&right == this) return *this;
560 return *this;
561}

◆ PrintAll()

void G4MolecularConfiguration::PrintAll ( )
static

Definition at line 1523 of file G4MolecularConfiguration.cc.

1524{
1525 const std::vector<G4MolecularConfiguration*>& species =
1527 G4cout<<G4endl;
1528 G4cout<<"Molecular Config"<<std::setw(25)<<" | Diffusion Coefficient (m2 / s) "<<std::setw(20)<<" | Radius (nm) "<<G4endl;
1529 G4cout<<"__________________________________________"
1530 "___________________________________"<<G4endl;
1531 for(auto specie : species)
1532 {
1533 G4cout<<specie->GetName()
1534 <<std::setw(G4int(30 - specie->GetName().length()))
1535 <<right<<specie->GetDiffusionCoefficient() * 1.0e3<<std::setw(30)
1536 <<specie->GetVanDerVaalsRadius()/CLHEP::nm<<G4endl;
1537 G4cout<<"__________________________________________"
1538 "___________________________________"<<G4endl;
1539 }
1540
1541}
int G4int
Definition G4Types.hh:85
#define G4endl
Definition G4ios.hh:67
G4GLOB_DLL std::ostream G4cout

Referenced by G4MoleculeTableMessenger::SetNewValue().

◆ PrintState()

void G4MolecularConfiguration::PrintState ( ) const

Display the electronic state of the molecule.

Definition at line 716 of file G4MolecularConfiguration.cc.

717{
718 G4cout << "-------------- Start Printing State " << GetName()
719 << " ---------------" << G4endl;
720
721 if (fElectronOccupancy != nullptr)
722 {
723 G4cout << "--------------Print electronic state of " << GetName()
724 << "---------------" << G4endl;
727 {
728 G4cout<<"At ground state"<<G4endl;
729 }
730 }
731 else
732 {
733 G4cout << "--- No electron occupancy set up ---" << G4endl;
734 }
735
736 G4cout << "Charge :"
737 << fDynCharge
738 << G4endl;
739
740 if(fLabel != nullptr)
741 {
742 G4cout << "Label :"
743 << GetLabel()
744 << G4endl;
745 }
746 G4cout << "-------------- End Of State " << GetName()
747 << " -----------------------" << G4endl;
748}

Referenced by CreateMolecularConfiguration(), CreateMolecularConfiguration(), IonizeMolecule(), MoveOneElectron(), G4Molecule::PrintState(), G4MoleculeCounter::RemoveAMoleculeAtTime(), and RemoveElectron().

◆ RemoveElectron()

G4MolecularConfiguration * G4MolecularConfiguration::RemoveElectron ( G4int orbit,
G4int number = 1 ) const

Remove n electrons to a given orbit.

Definition at line 629 of file G4MolecularConfiguration.cc.

631{
632// MakeExceptionIfFinalized();
633 CheckElectronOccupancy(__func__);
634 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
635
636 if (newElectronOccupancy.GetOccupancy(orbit) != 0)
637 {
638 newElectronOccupancy.RemoveElectron(orbit, number);
639 }
640 else
641 {
642 G4String errMsg = "There is already no electron into the orbit "
644 + " you want to free. The molecule's name is " + GetName();
645 G4Exception("G4MolecularConfiguration::RemoveElectron",
646 "",
648 errMsg);
649 PrintState();
650 }
651
652 return ChangeConfiguration(newElectronOccupancy);
653}

Referenced by G4Molecule::RemoveElectron().

◆ ReturnDefaultDiffCoeff()

double G4MolecularConfiguration::ReturnDefaultDiffCoeff ( const G4Material * ,
double ,
const G4MolecularConfiguration * molConf )
staticprotected

◆ ScaleAllDiffusionCoefficientsOnWater()

void G4MolecularConfiguration::ScaleAllDiffusionCoefficientsOnWater ( double temperature_K)
staticprotected

Definition at line 1443 of file G4MolecularConfiguration.cc.

1445{
1446 double D_water_0 = DiffCoeffWater(fgTemperature);
1447 double D_water_f = DiffCoeffWater(temperature_K);
1448
1449 G4cout << "Scaling factor = " << D_water_f/D_water_0 << G4endl;
1450
1453
1454 while(it())
1455 {
1456 G4MolecularConfiguration* conf = it.value();
1457 double D_0 = conf->GetDiffusionCoefficient() ;
1458 double D_f = D_water_f * D_0 /D_water_0;
1459 conf->SetDiffusionCoefficient(D_f);
1460 };
1461}
static double DiffCoeffWater(double temperature_K)
static G4MoleculeTable * Instance()
G4ConfigurationIterator GetConfigurationIterator()

Referenced by SetGlobalTemperature().

◆ Serialize()

void G4MolecularConfiguration::Serialize ( std::ostream & out)

Definition at line 1336 of file G4MolecularConfiguration.cc.

1337{
1338 G4String moleculeName = fMoleculeDefinition->GetName();
1339 WRITE(out, moleculeName);
1340
1341// if(fLabel)
1342// out << fLabel;
1343// else
1344// out << "";
1347 WRITE(out,fDynDecayTime);
1348 WRITE(out,fDynMass);
1349 WRITE(out,fDynCharge);
1350 WRITE(out,fMoleculeID);
1351 WRITE(out,fFormatedName);
1352 WRITE(out,fName);
1353 WRITE(out,fIsFinalized);
1354}
void WRITE(std::ostream &out, const T &toBeSaved)

◆ SetDecayTime()

void G4MolecularConfiguration::SetDecayTime ( G4double dynDecayTime)
inline

Set the decay time of the molecule.

Definition at line 496 of file G4MolecularConfiguration.hh.

497{
499 fDynDecayTime = dynDecayTime;
500}

Referenced by G4MoleculeDefinition::NewConfigurationWithElectronOccupancy().

◆ SetDiffusionCoefficient()

void G4MolecularConfiguration::SetDiffusionCoefficient ( G4double dynDiffusionCoefficient)
inline

Sets the diffusion coefficient D of the molecule used in diffusion processes to calculate the mean square jump distance between two changes of direction. In three dimension : <x^2> = 6 D t where t is the mean jump time between two changes of direction.

Note : Diffusion Coefficient in one medium only For the time being, we will consider only one diffusion coefficient for the all simulation => diffusion in one medium only If the user needs to use the diffusion in different materials, she/he should contact the developers/maintainers of this package

Definition at line 485 of file G4MolecularConfiguration.hh.

486{
488 fDynDiffusionCoefficient = dynDiffusionCoefficient;
489}

Referenced by G4EmDNAChemistry_option1::ConstructMolecule(), G4MoleculeTable::CreateConfiguration(), and ScaleAllDiffusionCoefficientsOnWater().

◆ SetGlobalTemperature()

void G4MolecularConfiguration::SetGlobalTemperature ( G4double temperature)
static

Definition at line 1475 of file G4MolecularConfiguration.cc.

1476{
1478 fgTemperature = temperature;
1479}
static void ScaleAllDiffusionCoefficientsOnWater(double temperature_K)

Referenced by G4DNAChemistryManager::SetGlobalTemperature().

◆ SetLabel()

void G4MolecularConfiguration::SetLabel ( const G4String & label)
inline

Definition at line 539 of file G4MolecularConfiguration.hh.

540{
541 assert(fLabel == 0 || *fLabel == "");
542 if(fLabel == nullptr)
543 {
544 fLabel = new G4String(label);
545 }
546 else
547 {
548 *fLabel = label;
549 }
551}

Referenced by CreateMolecularConfiguration(), CreateMolecularConfiguration(), CreateMolecularConfiguration(), and G4MolecularConfiguration().

◆ SetMass()

void G4MolecularConfiguration::SetMass ( G4double aMass)
inline

Set the total mass of the molecule.

Definition at line 523 of file G4MolecularConfiguration.hh.

524{
526 fDynMass = aMass;
527}

Referenced by G4ChemDissociationChannels::ConstructMolecule(), and G4ChemDissociationChannels_option1::ConstructMolecule().

◆ SetUserID()

void G4MolecularConfiguration::SetUserID ( const G4String & userID)

Definition at line 1423 of file G4MolecularConfiguration.cc.

1424{
1425 fUserIdentifier = userID;
1426 GetManager()->AddUserID(userID, this);
1427// G4MoleculeTable::Instance()->RecordMolecularConfiguration(userID, this);
1428}

◆ SetVanDerVaalsRadius()

void G4MolecularConfiguration::SetVanDerVaalsRadius ( G4double dynVanDerVaalsRadius)
inline

The Van Der Valls Radius of the molecule

Definition at line 507 of file G4MolecularConfiguration.hh.

508{
510 fDynVanDerVaalsRadius = dynVanDerVaalsRadius;
511}

Referenced by G4ChemDissociationChannels_option1::ConstructMolecule().

◆ UnFinalize()

void G4MolecularConfiguration::UnFinalize ( )
inline

Definition at line 585 of file G4MolecularConfiguration.hh.

586{
587 fIsFinalized = false;
588}

◆ Unserialize()

void G4MolecularConfiguration::Unserialize ( std::istream & in)

Definition at line 1358 of file G4MolecularConfiguration.cc.

1359{
1360 G4String moleculeName;
1361 READ(in, moleculeName);
1364
1365// G4String label;
1366//
1367// in.read((char*)(&label), sizeof(label));
1368//
1369// if(label)
1370// fLabel = new G4String(label);
1371// else
1372// fLabel = 0;
1375 READ(in,fDynDecayTime);
1376 READ(in,fDynMass);
1377 READ(in,fDynCharge);
1378 READ(in,fMoleculeID);
1379 READ(in,fFormatedName);
1380 READ(in,fName);
1381 READ(in,fIsFinalized);
1382}
void READ(std::istream &in, T &toBeSaved)
G4MoleculeDefinition * GetMoleculeDefinition(const G4String &, bool mustExist=true)

Referenced by G4MolecularConfiguration().

Member Data Documentation

◆ fDiffParam

◆ fDynCharge

◆ fDynDecayTime

G4double G4MolecularConfiguration::fDynDecayTime
protected

◆ fDynDiffusionCoefficient

◆ fDynMass

G4double G4MolecularConfiguration::fDynMass
protected

◆ fDynVanDerVaalsRadius

◆ fElectronOccupancy

◆ fFormatedName

G4String G4MolecularConfiguration::fFormatedName
protected

◆ fgManager

MolecularConfigurationManager * G4MolecularConfiguration::fgManager = nullptr
staticprotected

◆ fgTemperature

G4double G4MolecularConfiguration::fgTemperature = 298
staticprotected

◆ fIsFinalized

◆ fLabel

◆ fMoleculeDefinition

◆ fMoleculeID

◆ fName

G4String G4MolecularConfiguration::fName
protected

◆ fUserIdentifier


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