#include <G4MolecularConfiguration.hh>

Collaboration diagram for G4MolecularConfiguration:

Classes
class	G4MolecularConfigurationManager

Public Types
typedef std::function< double(const G4Material , double, const G4MolecularConfiguration )>	G4DiffCoeffParam

Public Member Functions
void	AddDiffCoeffParameterization (const G4DiffCoeffParam &)

const G4MoleculeDefinition *	GetDefinition () const

const G4String &	GetName () const

const G4String &	GetFormatedName () const

G4int	GetAtomsNumber () const

G4MolecularConfiguration *	ExciteMolecule (G4int)

G4MolecularConfiguration *	IonizeMolecule (G4int)

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

G4MolecularConfiguration *	RemoveElectron (G4int, G4int number=1)

G4MolecularConfiguration *	MoveOneElectron (G4int, G4int)

G4double	GetNbElectrons () const

void	PrintState () const

const std::vector< const G4MolecularDissociationChannel * > *	GetDecayChannel () 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 G4ElectronOccupancy *	GetElectronOccupancy () const

G4int	GetCharge () const

void	SetMass (G4double)

G4double	GetMass () const

void	SetLabel (const G4String &)

const G4String &	GetLabel () const

void	Finalize ()

const G4String &	GetUserID () const

void	Serialize (std::ostream &)

void	Unserialize (std::istream &)

Static Public Member Functions
static G4MolecularConfiguration *	GetOrCreateMolecularConfiguration (const G4MoleculeDefinition *)

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

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

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

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

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

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

static G4MolecularConfiguration *	GetMolecularConfiguration (const G4MoleculeDefinition *, const G4String &label)

static G4MolecularConfiguration *	GetMolecularConfiguration (int moleculeID)

static G4MolecularConfiguration *	GetMolecularConfiguration (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	SetGlobalTemperature (G4double)

static G4double	GetGlobalTemperature ()

static G4MolecularConfiguration *	Load (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 &)

G4MolecularConfiguration &	operator= (G4MolecularConfiguration &right)

	~G4MolecularConfiguration ()

G4MolecularConfiguration *	ChangeConfiguration (const G4ElectronOccupancy &newElectronOccupancy)

G4MolecularConfiguration *	ChangeConfiguration (int charge)

void	CheckElectronOccupancy (const char *line) const

void	MakeExceptionIfFinalized ()

void	SetUserID (const G4String &userID)

void	CreateDefaultDiffCoeffParam ()

Static Protected Member Functions
static void	ScaleAllDiffusionCoefficientsOnWater (double temperature_K)

static G4MolecularConfigurationManager *	GetManager ()

static double	ReturnDefaultDiffCoeff (const G4Material , double, const G4MolecularConfiguration molConf)

Protected Attributes
const G4MoleculeDefinition *	fMoleculeDefinition

const G4ElectronOccupancy *	fElectronOccupancy

G4String *	fLabel

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 G4MolecularConfigurationManager *	fgManager = 0

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 98 of file G4MolecularConfiguration.hh.

Member Typedef Documentation

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

Definition at line 104 of file G4MolecularConfiguration.hh.

Constructor & Destructor Documentation

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

protected

Definition at line 438 of file G4MolecularConfiguration.cc.

 {
   fMoleculeDefinition = moleculeDef;
 
   fMoleculeID = GetManager()->Insert(moleculeDef,
                                      elecOcc,
                                      this);
   fElectronOccupancy = GetManager()->FindCommonElectronOccupancy(moleculeDef,
                                                                  elecOcc);
 
   /*
    fgManager->fTable[fMoleculeDefinition][elecOcc] = this;
    std::map<G4ElectronOccupancy, G4MolecularConfiguration*, comparator>::iterator it ;
    it = fgManager->fTable[moleculeDef].find(elecOcc);
    fElectronOccupancy = &(it->first);
    */
 
   fDynCharge = fMoleculeDefinition->GetNbElectrons()
       - fElectronOccupancy->GetTotalOccupancy()
                + moleculeDef->GetCharge();
   fDynMass = fMoleculeDefinition->GetMass();
 
   fDynDiffusionCoefficient = fMoleculeDefinition->GetDiffusionCoefficient();
   fDynVanDerVaalsRadius = fMoleculeDefinition->GetVanDerVaalsRadius();
   fDynDecayTime = fMoleculeDefinition->GetDecayTime();
 
   fName = fMoleculeDefinition->GetName();
   fName += "^";
   fName += G4UIcommand::ConvertToString(fDynCharge);
 
   fFormatedName = fMoleculeDefinition->GetFormatedName();
   fFormatedName += "^";
   fFormatedName += "{";
   fFormatedName += G4UIcommand::ConvertToString(fDynCharge);
   fFormatedName += "}";
 
   fLabel = 0; // let it here
 
   if(label != "")
   {
     SetLabel(label);
   }
 
   fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
 
   fIsFinalized = false;
 }

Here is the call graph for this function:

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

protected

Definition at line 491 of file G4MolecularConfiguration.cc.

 {
   fMoleculeDefinition = moleculeDef;
 
   fMoleculeID = GetManager()->Insert(moleculeDef,
                                      charge,
                                      this);
   fElectronOccupancy = 0;
 
   fDynCharge = charge;
   fDynMass = fMoleculeDefinition->GetMass();
 
   fDynDiffusionCoefficient = fMoleculeDefinition->GetDiffusionCoefficient();
   fDynVanDerVaalsRadius = fMoleculeDefinition->GetVanDerVaalsRadius();
   fDynDecayTime = fMoleculeDefinition->GetDecayTime();
 
   fName = fMoleculeDefinition->GetName();
   fName += "^";
   fName += G4UIcommand::ConvertToString(fDynCharge);
 
   fFormatedName = fMoleculeDefinition->GetFormatedName();
   fFormatedName += "^";
   fFormatedName += "{";
   fFormatedName += G4UIcommand::ConvertToString(fDynCharge);
   fFormatedName += "}";
 
   fLabel = 0;
 
   fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
 
   fIsFinalized = false;
 }

Here is the call graph for this function:

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

protected

Definition at line 80 of file G4MolecularConfiguration.cc.

 {
   fMoleculeDefinition = moleculeDef;
 
   fLabel = new G4String(label);
 
   fMoleculeID = GetManager()->Insert(moleculeDef,
                                      label,
                                      this);
   fElectronOccupancy = 0;
 
   fDynCharge = charge;
 
   fDynMass = fMoleculeDefinition->GetMass();
 
   fDynDiffusionCoefficient = fMoleculeDefinition->GetDiffusionCoefficient();
   fDynVanDerVaalsRadius = fMoleculeDefinition->GetVanDerVaalsRadius();
   fDynDecayTime = fMoleculeDefinition->GetDecayTime();
 
   fName = fMoleculeDefinition->GetName();
   fName += "^";
   fName += G4UIcommand::ConvertToString(fDynCharge);
 
   fFormatedName = fMoleculeDefinition->GetFormatedName();
   fFormatedName += "^";
   fFormatedName += "{";
   fFormatedName += G4UIcommand::ConvertToString(fDynCharge);
   fFormatedName += "}";
 
   fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
   fIsFinalized = false;
 }

Here is the call graph for this function:

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

protected

Definition at line 1444 of file G4MolecularConfiguration.cc.

 {
   fLabel = 0; // TODO: for now not serialized
   Unserialize(in);
   fMoleculeDefinition = 0;
   fElectronOccupancy = 0;
   if(fElectronOccupancy)
   {
     GetManager()->Insert(fMoleculeDefinition, *fElectronOccupancy, this);
     fElectronOccupancy =
         GetManager()->FindCommonElectronOccupancy(fMoleculeDefinition,
                                                   *fElectronOccupancy);
 
     if(fLabel)
     {
       GetManager()->RecordNewlyLabeledConfiguration(this);
     }
   }
   else if(fLabel)
   {
     fMoleculeID = GetManager()->Insert(fMoleculeDefinition, *fLabel, this);
   }
   else if(fDynCharge)
   {
     fMoleculeID = GetManager()->Insert(fMoleculeDefinition, fDynCharge, this);
   }
 }

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MolecularConfiguration & )

protected

G4MolecularConfiguration::~G4MolecularConfiguration ( )

protected

Definition at line 527 of file G4MolecularConfiguration.cc.

 {
   if (fgManager) fgManager->RemoveMolecularConfigurationFromTable(this);
 
 //  if (G4AllocatorList::GetAllocatorListIfExist())
 //  {
 //    if (fElectronOccupancy)
 //    {
 //      delete fElectronOccupancy;
 //      fElectronOccupancy = 0;
 //    }
 //  }
 }

Member Function Documentation

void G4MolecularConfiguration::AddDiffCoeffParameterization ( const G4DiffCoeffParam & para )

inline

Definition at line 586 of file G4MolecularConfiguration.hh.

 {
   fDiffParam = para;
 }

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

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 636 of file G4MolecularConfiguration.cc.

 {
 //  MakeExceptionIfFinalized();
   CheckElectronOccupancy(__func__);
   G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
   newElectronOccupancy.AddElectron(orbit, number);
   return ChangeConfiguration(newElectronOccupancy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 545 of file G4MolecularConfiguration.cc.

 {
   G4MolecularConfiguration* output =
       GetManager()->GetMolecularConfiguration(fMoleculeDefinition,
                                               newElectronOccupancy);
 
   if (!output)
   {
     output = new G4MolecularConfiguration(fMoleculeDefinition,
                                           newElectronOccupancy);
   }
   return output;
 }

Here is the call graph for this function:

G4MolecularConfiguration * G4MolecularConfiguration::ChangeConfiguration ( int charge )

protected

Definition at line 562 of file G4MolecularConfiguration.cc.

 {
   G4MolecularConfiguration* output =
       GetManager()->GetMolecularConfiguration(fMoleculeDefinition, charge);
 
   if (!output)
   {
     output = new G4MolecularConfiguration(fMoleculeDefinition, charge);
   }
   return output;
 }

Here is the call graph for this function:

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

protected

Definition at line 824 of file G4MolecularConfiguration.cc.

 {
   if (fElectronOccupancy == 0)
   {
     G4String functionName(function);
     G4ExceptionDescription description;
     description
         << "No G4ElectronOccupancy was defined for molecule definition : "
         << fMoleculeDefinition->GetName()
         << ". The definition was probably defined using the charge state, "
             "rather than electron state.";
 
     G4Exception(functionName, "", FatalErrorInArgument, description);
   }
 }

Here is the call graph for this function:

void G4MolecularConfiguration::CreateDefaultDiffCoeffParam ( )

protected

Definition at line 1516 of file G4MolecularConfiguration.cc.

 {
   if(bool(fDiffParam) == false)
   {
     fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 1099 of file G4MolecularConfiguration.cc.

 {
   wasAlreadyCreated = false;
   G4MolecularConfiguration* preRegisteredMolConf =
       GetManager()->GetMolecularConfiguration(userIdentifier);
 
   if(preRegisteredMolConf)
   {
     if(preRegisteredMolConf->GetDefinition() == molDef)
     {
       wasAlreadyCreated = true;
       return preRegisteredMolConf;
     }
   }
 
   if(molDef->GetGroundStateElectronOccupancy())
   {
     const G4ElectronOccupancy& elecOcc = *molDef
         ->GetGroundStateElectronOccupancy();
     G4MolecularConfiguration* molConf =
         GetManager()->GetMolecularConfiguration(molDef, elecOcc);
 
     if(molConf)
     {
       if(molConf->fUserIdentifier == "")
       {
         molConf->fUserIdentifier = userIdentifier;
       }
       else if(molConf->fUserIdentifier != userIdentifier)
       {
         G4ExceptionDescription errMsg;
         errMsg << "A molecular configuration for the definition named "
                << molDef->GetName() << " has already been created "
                "and recorded with a different user ID "
                << molConf->fUserIdentifier;
         G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                     "DOUBLE_CREATION",
                     FatalErrorInArgument,
                     errMsg);
       }
 // TODO exception
       G4ExceptionDescription errMsg;
       errMsg << "A molecular configuration for the definition named "
              << molDef->GetName() << " has already been created.";
       G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                   "DOUBLE_CREATION",
                   JustWarning,
                   errMsg);
       wasAlreadyCreated = true;
       return molConf;
     }
     else
     {
       // G4cout << "Create molConf for " << molDef->GetName() << G4endl;
       G4MolecularConfiguration* newConf = new G4MolecularConfiguration(molDef,
                                                                        elecOcc);
       newConf->fUserIdentifier = userIdentifier;
 
       GetManager()->AddUserID(userIdentifier, newConf);
 
 //      G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
 //                                                                newConf);
       return newConf;
     }
   }
   else
   {
     return CreateMolecularConfiguration(userIdentifier,
                                         molDef,
                                         molDef->GetName(),
                                         molDef->GetCharge(),
                                         wasAlreadyCreated);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 1246 of file G4MolecularConfiguration.cc.

 {
   assert(label != "");
   wasAlreadyCreated = false;
 
   G4MolecularConfiguration* molConf =
       GetManager()->GetMolecularConfiguration(molDef, eOcc);
 
   if(molConf)
   {
     if(molConf->GetElectronOccupancy())
     {
       if(*molConf->GetElectronOccupancy() == eOcc)
       {
         if(molConf->fLabel && *molConf->fLabel == label)
         {
           wasAlreadyCreated = true;
           return molConf;
         }
         else if(molConf->fLabel == 0)
         {
           wasAlreadyCreated = true;
           molConf->SetLabel(label);
           return molConf;
         }
         else if(*molConf->fLabel == "")
         {
           wasAlreadyCreated = true;
           molConf->SetLabel(label);
           return molConf;
         }
       }
     }
 
 
     molConf->PrintState();
     G4ExceptionDescription errMsg ;
     errMsg << "A molecular configuration for the definition named "
            << molDef->GetName()
            << " has already been created "
               "with user ID "
            << molConf->fUserIdentifier
            << " and possible different electronic state";
     G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                 "DOUBLE_CREATION",
                 FatalErrorInArgument,
                 errMsg);
   }
   else
   {
     G4MolecularConfiguration* newConf =
       new G4MolecularConfiguration(molDef,
                                    eOcc,
                                    label);
     newConf->fUserIdentifier = userIdentifier;
 
     GetManager()->AddUserID(userIdentifier, newConf);
 
 //    G4MoleculeTable::Instance()->
 //        RecordMolecularConfiguration(userIdentifier, newConf);
     return newConf;
   }
   return molConf;
 }

Here is the call graph for this function:

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

static

Definition at line 1006 of file G4MolecularConfiguration.cc.

 {
   wasAlreadyCreated = false;
   G4MolecularConfiguration* molConf =
       GetManager()->GetMolecularConfiguration(molDef, charge);
 
   if (molConf)
   {
     if(molConf->fLabel == 0)
     {
       molConf->SetLabel(label);
       G4ExceptionDescription wMsg ;
       wMsg << "The molecular configuration for the definition named "
              << molDef->GetName()
              << " with charge " << charge << " has already been created "
                  "but with NO label";
       G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                   "DOUBLE_CREATION",
                   JustWarning,
                   wMsg);
     }
     else if(*(molConf->fLabel) == "" )
     {
       molConf->SetLabel(label);
     }
     else if(*(molConf->fLabel) != label)
     {
       G4ExceptionDescription errMsg ;
       errMsg << "The molecular configuration for the definition named "
              << molDef->GetName()
              << " with charge " << charge << " has already been created "
                  "but with a different label :"
              << molConf->GetLabel();
       G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                   "DOUBLE_CREATION",
                   FatalErrorInArgument,
                   errMsg);
       // KILL APP
     }
 
     if(molConf->fUserIdentifier == "")
     {
       molConf->fUserIdentifier = userIdentifier;
 
       G4ExceptionDescription wMsg ;
       wMsg << "The molecular configuration for the definition named "
              << molDef->GetName()
              << " with label " << label << " has already been created.";
       G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                   "DOUBLE_CREATION",
                   JustWarning,
                   wMsg);
     }
     else if(molConf->fUserIdentifier != userIdentifier)
     {
       G4ExceptionDescription errMsg ;
       errMsg << "The molecular configuration for the definition named "
              << molDef->GetName()
              << " with label " << label << " has already been created "
                  "BUT with a different user ID :"
              << molConf->fUserIdentifier;
       G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                   "DOUBLE_CREATION",
                   FatalErrorInArgument,
                   errMsg);
       // KILL APP
     }
 
     wasAlreadyCreated = true;
     return molConf;
   }
   else
   {
     G4MolecularConfiguration* newConf =
         new G4MolecularConfiguration(molDef, label, charge);
     newConf->fUserIdentifier = userIdentifier;
 
     GetManager()->AddUserID(userIdentifier, newConf);
 
 //    G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
 //                                                              newConf);
     return newConf;
   }
 }

Here is the call graph for this function:

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

static

Definition at line 1180 of file G4MolecularConfiguration.cc.

 {
   assert(label != "");
   wasAlreadyCreated = false;
 
   G4MolecularConfiguration* molConf =
       GetManager()->GetMolecularConfiguration(molDef, label);
   if(molConf)
   {
     if(molConf->fLabel
        && *molConf->fLabel == label)
     {
       wasAlreadyCreated = true;
       return molConf;
     }
     else if(molConf->fLabel == 0)
     {
       wasAlreadyCreated = true;
       molConf->SetLabel(label);
       return molConf;
     }
     else if(*molConf->fLabel == "")
     {
       wasAlreadyCreated = true;
       molConf->SetLabel(label);
       return molConf;
     }
 
     molConf->PrintState();
     G4ExceptionDescription errMsg ;
     errMsg << "A molecular configuration for the definition named "
            << molDef->GetName()
            << " has already been created "
               "with user ID "
            << molConf->fUserIdentifier << " and label "
            << molConf->GetLabel();
     G4Exception("G4MolecularConfiguration::CreateMolecularConfiguration",
                 "DOUBLE_CREATION",
                 FatalErrorInArgument,
                 errMsg);
     // KILL APP
   }
   else
   {
     G4MolecularConfiguration* newConf =
       new G4MolecularConfiguration(molDef,
                                    label,
                                    molDef->GetCharge());
     newConf->fUserIdentifier = userIdentifier;
 
     GetManager()->AddUserID(userIdentifier, newConf);
 
 //    G4MoleculeTable::Instance()->
 //        RecordMolecularConfiguration(userIdentifier, newConf);
     return newConf;
   }
   return molConf;
 }

Here is the call graph for this function:

void G4MolecularConfiguration::DeleteManager ( )

static

Definition at line 427 of file G4MolecularConfiguration.cc.

 {
   G4AutoLock lock(&MolecularConfigurationManager::fManagerCreationMutex);
   if (fgManager) delete fgManager;
   fgManager = 0;
   lock.unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G4MolecularConfiguration::DiffCoeffWater ( double temperature_K )

static

Definition at line 1483 of file G4MolecularConfiguration.cc.

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

Here is the caller graph for this function:

G4MolecularConfiguration * G4MolecularConfiguration::ExciteMolecule ( G4int ExcitedLevel )

Method used in Geant4-DNA to excite water molecules

Definition at line 588 of file G4MolecularConfiguration.cc.

 {
 //  MakeExceptionIfFinalized();
   CheckElectronOccupancy(__func__);
   G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
 
   newElectronOccupancy.RemoveElectron(ExcitedLevel, 1);
   newElectronOccupancy.AddElectron(5, 1);
 
   return ChangeConfiguration(newElectronOccupancy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4MolecularConfiguration::Finalize ( )

inline

Definition at line 574 of file G4MolecularConfiguration.hh.

 {
   CreateDefaultDiffCoeffParam();
   fIsFinalized = true;
 }

Here is the call graph for this function:

void G4MolecularConfiguration::FinalizeAll ( )

static

Definition at line 1562 of file G4MolecularConfiguration.cc.

 {
   const std::vector<G4MolecularConfiguration*>& species =
       GetManager()->GetAllSpecies();
 
   for(size_t i = 0; i < species.size() ; ++i)
   {
     species[i]->Finalize();
   }
 
 }

Here is the caller graph for this function:

G4int G4MolecularConfiguration::GetAtomsNumber ( ) const

Returns the nomber of atoms compouning the molecule

Definition at line 737 of file G4MolecularConfiguration.cc.

 {
   return fMoleculeDefinition->GetAtomsNumber();
 }

Here is the caller graph for this function:

G4int G4MolecularConfiguration::GetCharge ( ) const

inline

Returns the charge of molecule.

Definition at line 531 of file G4MolecularConfiguration.hh.

 {
   return fDynCharge;
 }

Here is the caller graph for this function:

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

Definition at line 790 of file G4MolecularConfiguration.cc.

 {
   // if (fElectronOccupancy == 0) return 0;
   return fMoleculeDefinition->GetDecayChannels(this);
 }

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetDecayTime ( ) const

inline

Returns the decay time of the molecule.

Definition at line 515 of file G4MolecularConfiguration.hh.

 {
   return fDynDecayTime;
 }

Here is the caller graph for this function:

const G4MoleculeDefinition * G4MolecularConfiguration::GetDefinition ( ) const

inline

Definition at line 488 of file G4MolecularConfiguration.hh.

 {
   return fMoleculeDefinition;
 }

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetDiffusionCoefficient ( ) const

inline

Returns the diffusion coefficient D.

Definition at line 504 of file G4MolecularConfiguration.hh.

 {
   return fDynDiffusionCoefficient;
 }

Here is the caller graph for this function:

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

inline

Definition at line 592 of file G4MolecularConfiguration.hh.

 {
   return fDiffParam(material, temperature, this);
 }

const G4ElectronOccupancy * G4MolecularConfiguration::GetElectronOccupancy ( ) const

inline

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

Definition at line 493 of file G4MolecularConfiguration.hh.

 {
   return fElectronOccupancy;
 }

Here is the caller graph for this function:

G4int G4MolecularConfiguration::GetFakeParticleID ( ) const

Definition at line 798 of file G4MolecularConfiguration.cc.

 {
   if(fMoleculeDefinition) return fMoleculeDefinition->GetPDGEncoding();
   else G4Exception("G4MolecularConfiguration::GetMoleculeID",
                    "",
                    FatalErrorInArgument,
                    "You should first enter a molecule defintion");
 
   return INT_MAX;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4String & G4MolecularConfiguration::GetFormatedName ( ) const

Returns the formated name of the molecule

Definition at line 722 of file G4MolecularConfiguration.cc.

 {
 //  if (fFormatedName.isNull())
 //  {
 //    fFormatedName = fMoleculeDefinition->GetFormatedName();
 //    fFormatedName += "^";
 //    fFormatedName += "{";
 //    fFormatedName += G4UIcommand::ConvertToString(fDynCharge);
 //    fFormatedName += "}";
 //  }
   return fFormatedName;
 }

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetGlobalTemperature ( )

static

Definition at line 1534 of file G4MolecularConfiguration.cc.

 {
   return fgTemperature;
 }

Here is the caller graph for this function:

const G4String & G4MolecularConfiguration::GetLabel ( ) const

inline

Definition at line 566 of file G4MolecularConfiguration.hh.

 {
   if(fLabel == 0)
     fLabel = new G4String();
 
   return (*fLabel);
 }

Here is the caller graph for this function:

G4MolecularConfiguration::G4MolecularConfigurationManager * G4MolecularConfiguration::GetManager ( )

staticprotected

Definition at line 131 of file G4MolecularConfiguration.cc.

 {
   if (!fgManager)
   {
     G4AutoLock lock(&MolecularConfigurationManager::fManagerCreationMutex);
     if (!fgManager) // double check for MT
     {
       fgManager = new G4MolecularConfiguration::
           G4MolecularConfigurationManager();
     }
     lock.unlock();
   }
 
   return fgManager;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetMass ( ) const

inline

Returns the total mass of the molecule.

Definition at line 542 of file G4MolecularConfiguration.hh.

 {
   return fDynMass;
 }

Here is the caller graph for this function:

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration	(	const G4MoleculeDefinition *	molDef,
		const G4String &	label
	)

static

Definition at line 989 of file G4MolecularConfiguration.cc.

 {
   return GetManager()->GetMolecularConfiguration(molDef, label);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration ( int moleculeID )

static

Definition at line 998 of file G4MolecularConfiguration.cc.

 {
   return GetManager()->GetMolecularConfiguration(moleculeID);
 }

Here is the call graph for this function:

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

static

Definition at line 1555 of file G4MolecularConfiguration.cc.

 {
   return GetManager()->GetMolecularConfiguration(userID);
 }

Here is the call graph for this function:

G4int G4MolecularConfiguration::GetMoleculeID ( ) const

inline

Definition at line 547 of file G4MolecularConfiguration.hh.

 {
   return fMoleculeID;
 }

Here is the caller graph for this function:

const G4String & G4MolecularConfiguration::GetName ( ) const

Returns the name of the molecule

Definition at line 707 of file G4MolecularConfiguration.cc.

 {
 //  if (fName.isNull())
 //  {
 //    fName = fMoleculeDefinition->GetName();
 //    fName += "^";
 //    // fName+= "{";
 //    fName += G4UIcommand::ConvertToString(fDynCharge);
 //    // fName+= "}";
 //  }
   return fName;
 }

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetNbElectrons ( ) const

Returns the number of electron.

Definition at line 744 of file G4MolecularConfiguration.cc.

 {
   CheckElectronOccupancy(__func__);
   return fElectronOccupancy->GetTotalOccupancy();
 }

Here is the caller graph for this function:

int G4MolecularConfiguration::GetNumberOfSpecies ( )

static

Definition at line 67 of file G4MolecularConfiguration.cc.

 {
   return GetManager()->GetNumberOfCreatedSpecies();
 }

Here is the caller graph for this function:

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

static

Definition at line 339 of file G4MolecularConfiguration.cc.

 {
   if (molDef->GetGroundStateElectronOccupancy())
   {
     const G4ElectronOccupancy& elecOcc =
         *molDef->GetGroundStateElectronOccupancy();
     G4MolecularConfiguration* molConf =
         GetManager()->GetMolecularConfiguration(molDef, elecOcc);
 
     if (molConf)
     {
       return molConf;
     }
     else
     {
       G4MolecularConfiguration* newConf =
           new G4MolecularConfiguration(molDef,
                                        elecOcc);
       newConf->SetUserID(molDef->GetName());
       return newConf;
     }
   }
   else
   {
     G4MolecularConfiguration* molConf =
         GetManager()->GetMolecularConfiguration(molDef, molDef->GetCharge());
     if(molConf)
     {
       return molConf;
     }
     else
     {
       G4MolecularConfiguration* newConf =
           new G4MolecularConfiguration(molDef, molDef->GetCharge());
       newConf->SetUserID(molDef->GetName());
       return newConf;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 383 of file G4MolecularConfiguration.cc.

 {
   return GetManager()->GetOrCreateMolecularConfiguration(molDef, elecOcc);
 
 //  G4MolecularConfiguration* molConf =
 //      GetManager()->GetMolecularConfiguration(molDef, elecOcc);
 //
 //  if (molConf)
 //  {
 //    return molConf;
 //  }
 //  else
 //  {
 //    G4MolecularConfiguration* newConf =
 //        new G4MolecularConfiguration(molDef, elecOcc);
 //    return newConf;
 //  }
 }

Here is the call graph for this function:

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

static

Definition at line 407 of file G4MolecularConfiguration.cc.

 {
   G4MolecularConfiguration* molConf =
       GetManager()->GetMolecularConfiguration(molDef, charge);
 
   if(molConf)
   {
     return molConf;
   }
   else
   {
     G4MolecularConfiguration* newConf =
         new G4MolecularConfiguration(molDef, charge);
     return newConf;
   }
 }

Here is the call graph for this function:

const G4String & G4MolecularConfiguration::GetUserID ( ) const

inline

Definition at line 580 of file G4MolecularConfiguration.hh.

 {
   return fUserIdentifier;
 }

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

inlinestatic

Definition at line 169 of file G4MolecularConfiguration.hh.

   {
     return GetManager()->GetUserIDTable();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4MolecularConfiguration::GetVanDerVaalsRadius ( ) const

inline

Definition at line 526 of file G4MolecularConfiguration.hh.

 {
   return fDynVanDerVaalsRadius;
 }

Here is the caller graph for this function:

G4MolecularConfiguration * G4MolecularConfiguration::IonizeMolecule ( G4int IonizedLevel )

Method used in Geant4-DNA to ionize water molecules

Definition at line 605 of file G4MolecularConfiguration.cc.

 {
 //  MakeExceptionIfFinalized();
   CheckElectronOccupancy(__func__);
   G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
 
   if (newElectronOccupancy.GetOccupancy(IonizedLevel) != 0)
   {
     newElectronOccupancy.RemoveElectron(IonizedLevel, 1);
   }
   else
   {
     G4String errMsg = "There is no electron on the orbit "
         + G4UIcommand::ConvertToString(IonizedLevel)
         + " you want to free. The molecule's name you want to ionized is "
         + GetName();
     G4Exception("G4MolecularConfiguration::IonizeMolecule",
                 "",
                 FatalErrorInArgument,
                 errMsg);
     PrintState();
   }
 
   // DEBUG
   // PrintState();
 
   return ChangeConfiguration(newElectronOccupancy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 1437 of file G4MolecularConfiguration.cc.

 {
   return new G4MolecularConfiguration(in);
 }

void G4MolecularConfiguration::MakeExceptionIfFinalized ( )

protected

Definition at line 115 of file G4MolecularConfiguration.cc.

 {
   if(fIsFinalized)
   {
     G4ExceptionDescription errMsg;
     errMsg << "This molecular configuration " << GetName()
            << " is already finalized. Therefore its "
            " properties cannot be changed.";
     G4Exception("G4MolecularConfiguration::MakeExceptionIfFinalized",
                 "CONF_FINALIZED",FatalException,errMsg);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Move one electron from an orbit to another.

Definition at line 678 of file G4MolecularConfiguration.cc.

 {
 //  MakeExceptionIfFinalized();
   CheckElectronOccupancy(__func__);
   G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
 
   if (newElectronOccupancy.GetOccupancy(orbitToFree) >= 1)
   {
     newElectronOccupancy.RemoveElectron(orbitToFree, 1);
     newElectronOccupancy.AddElectron(orbitToFill, 1);
   }
   else
   {
     G4String errMsg = "There is no electron on the orbit "
         + G4UIcommand::ConvertToString(orbitToFree)
         + " you want to free. The molecule's name is " + GetName();
     G4Exception("G4MolecularConfiguration::MoveOneElectron",
                 "",
                 FatalErrorInArgument,
                 errMsg);
     PrintState();
   }
 
   return ChangeConfiguration(newElectronOccupancy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 577 of file G4MolecularConfiguration.cc.

 {
 //  if (&right == this) return *this;
   return *this;
 }

void G4MolecularConfiguration::PrintState ( ) const

Display the electronic state of the molecule.

Definition at line 752 of file G4MolecularConfiguration.cc.

 {
   G4cout << "-------------- Start Printing State " << GetName()
          << " ---------------" << G4endl;
 
   if (fElectronOccupancy)
   {
     G4cout << "--------------Print electronic state of " << GetName()
            << "---------------" << G4endl;
     fElectronOccupancy->DumpInfo();
     if(fElectronOccupancy==fMoleculeDefinition->GetGroundStateElectronOccupancy())
     {
       G4cout<<"At ground state"<<G4endl;
     }
   }
   else
   {
     G4cout << "--- No electron occupancy set up ---" << G4endl;
   }
 
   G4cout << "Charge :"
          << fDynCharge
          << G4endl;
 
   if(fLabel)
   {
     G4cout << "Label :"
            << GetLabel()
            << G4endl;
   }
   G4cout  << "-------------- End Of State " << GetName()
           << " -----------------------" << G4endl;
 }

Here is the caller graph for this function:

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

Remove n electrons to a given orbit.

Definition at line 649 of file G4MolecularConfiguration.cc.

 {
 //  MakeExceptionIfFinalized();
   CheckElectronOccupancy(__func__);
   G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
 
   if (newElectronOccupancy.GetOccupancy(orbit) != 0)
   {
     newElectronOccupancy.RemoveElectron(orbit, number);
   }
   else
   {
     G4String errMsg = "There is already no electron into the orbit "
         + G4UIcommand::ConvertToString(orbit)
         + " you want to free. The molecule's name is " + GetName();
     G4Exception("G4MolecularConfiguration::RemoveElectron",
                 "",
                 JustWarning,
                 errMsg);
     PrintState();
   }
 
   return ChangeConfiguration(newElectronOccupancy);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

staticprotected

Definition at line 72 of file G4MolecularConfiguration.cc.

 {
   return molConf->fDynDiffusionCoefficient;
 }

Here is the caller graph for this function:

void G4MolecularConfiguration::ScaleAllDiffusionCoefficientsOnWater ( double temperature_K )

staticprotected

Definition at line 1495 of file G4MolecularConfiguration.cc.

 {
   double D_water_0 = DiffCoeffWater(fgTemperature);
   double D_water_f = DiffCoeffWater(temperature_K);
 
   G4cout << "Scaling factor = " << D_water_f/D_water_0 << G4endl;
 
   G4ConfigurationIterator it =
       G4MoleculeTable::Instance()->GetConfigurationIterator();
 
   while(it())
   {
     G4MolecularConfiguration* conf = it.value();
     double D_0 = conf->GetDiffusionCoefficient() ;
     double D_f = D_water_f * D_0 /D_water_0;
     conf->SetDiffusionCoefficient(D_f);
   };
 }

Here is the call graph for this function:

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

Definition at line 1387 of file G4MolecularConfiguration.cc.

 {
   G4String moleculeName = fMoleculeDefinition->GetName();
   WRITE(out, moleculeName);
 
 //  if(fLabel)
 //   out << fLabel;
 //  else
 //    out << "";
   WRITE(out,fDynDiffusionCoefficient);
   WRITE(out,fDynVanDerVaalsRadius);
   WRITE(out,fDynDecayTime);
   WRITE(out,fDynMass);
   WRITE(out,fDynCharge);
   WRITE(out,fMoleculeID);
   WRITE(out,fFormatedName);
   WRITE(out,fName);
   WRITE(out,fIsFinalized);
 }

Here is the call graph for this function:

void G4MolecularConfiguration::SetDecayTime ( G4double dynDecayTime )

inline

Set the decay time of the molecule.

Definition at line 509 of file G4MolecularConfiguration.hh.

 {
   MakeExceptionIfFinalized();
   fDynDecayTime = dynDecayTime;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 developpers/mainteners of this package

Definition at line 498 of file G4MolecularConfiguration.hh.

 {
   MakeExceptionIfFinalized();
   fDynDiffusionCoefficient = dynDiffusionCoefficient;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4MolecularConfiguration::SetGlobalTemperature ( G4double temperature )

static

Definition at line 1526 of file G4MolecularConfiguration.cc.

 {
   ScaleAllDiffusionCoefficientsOnWater(temperature);
   fgTemperature = temperature;
 }

Here is the caller graph for this function:

void G4MolecularConfiguration::SetLabel ( const G4String & label )

inline

Definition at line 552 of file G4MolecularConfiguration.hh.

 {
   assert(fLabel == 0 || *fLabel == "");
   if(fLabel == 0)
   {
     fLabel = new G4String(label);
   }
   else
   {
     *fLabel = label;
   }
   fgManager->RecordNewlyLabeledConfiguration(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4MolecularConfiguration::SetMass ( G4double aMass )

inline

Set the total mass of the molecule.

Definition at line 536 of file G4MolecularConfiguration.hh.

 {
   MakeExceptionIfFinalized();
   fDynMass = aMass;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4MolecularConfiguration::SetUserID ( const G4String & userID )

protected

Definition at line 1474 of file G4MolecularConfiguration.cc.

 {
   fUserIdentifier = userID;
   GetManager()->AddUserID(userID, this);
 //  G4MoleculeTable::Instance()->RecordMolecularConfiguration(userID, this);
 }

Here is the caller graph for this function:

void G4MolecularConfiguration::SetVanDerVaalsRadius ( G4double dynVanDerVaalsRadius )

inline

The Van Der Valls Radius of the molecule

Definition at line 520 of file G4MolecularConfiguration.hh.

 {
   MakeExceptionIfFinalized();
   fDynVanDerVaalsRadius = dynVanDerVaalsRadius;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1409 of file G4MolecularConfiguration.cc.

 {
   G4String moleculeName;
   READ(in, moleculeName);
   fMoleculeDefinition =
       G4MoleculeTable::Instance()->GetMoleculeDefinition(moleculeName);
 
 //  G4String label;
 //
 //  in.read((char*)(&label), sizeof(label));
 //
 //  if(label)
 //   fLabel = new G4String(label);
 //  else
 //    fLabel = 0;
   READ(in,fDynDiffusionCoefficient);
   READ(in,fDynVanDerVaalsRadius);
   READ(in,fDynDecayTime);
   READ(in,fDynMass);
   READ(in,fDynCharge);
   READ(in,fMoleculeID);
   READ(in,fFormatedName);
   READ(in,fName);
   READ(in,fIsFinalized);
 }

Here is the call graph for this function:

Member Data Documentation

G4DiffCoeffParam G4MolecularConfiguration::fDiffParam

protected

Definition at line 479 of file G4MolecularConfiguration.hh.

G4int G4MolecularConfiguration::fDynCharge

protected

Definition at line 472 of file G4MolecularConfiguration.hh.

G4double G4MolecularConfiguration::fDynDecayTime

protected

Definition at line 470 of file G4MolecularConfiguration.hh.

G4double G4MolecularConfiguration::fDynDiffusionCoefficient

protected

Definition at line 468 of file G4MolecularConfiguration.hh.

G4double G4MolecularConfiguration::fDynMass

protected

Definition at line 471 of file G4MolecularConfiguration.hh.

G4double G4MolecularConfiguration::fDynVanDerVaalsRadius

protected

Definition at line 469 of file G4MolecularConfiguration.hh.

const G4ElectronOccupancy* G4MolecularConfiguration::fElectronOccupancy

protected

Definition at line 464 of file G4MolecularConfiguration.hh.

G4String G4MolecularConfiguration::fFormatedName

protected

Definition at line 474 of file G4MolecularConfiguration.hh.

MolecularConfigurationManager * G4MolecularConfiguration::fgManager = 0

staticprotected

Definition at line 460 of file G4MolecularConfiguration.hh.

G4double G4MolecularConfiguration::fgTemperature = 298

staticprotected

Definition at line 480 of file G4MolecularConfiguration.hh.

G4bool G4MolecularConfiguration::fIsFinalized

protected

Definition at line 477 of file G4MolecularConfiguration.hh.

G4String* G4MolecularConfiguration::fLabel

mutableprotected

Definition at line 466 of file G4MolecularConfiguration.hh.

const G4MoleculeDefinition* G4MolecularConfiguration::fMoleculeDefinition

protected

Definition at line 463 of file G4MolecularConfiguration.hh.

G4int G4MolecularConfiguration::fMoleculeID

protected

Definition at line 473 of file G4MolecularConfiguration.hh.

G4String G4MolecularConfiguration::fName

protected

Definition at line 475 of file G4MolecularConfiguration.hh.

G4String G4MolecularConfiguration::fUserIdentifier

protected

Definition at line 476 of file G4MolecularConfiguration.hh.

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

geant4.10.03.p01/source/processes/electromagnetic/dna/molecules/management/include/G4MolecularConfiguration.hh
geant4.10.03.p01/source/processes/electromagnetic/dna/molecules/management/src/G4MolecularConfiguration.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation