#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 G4MoleculeDefinition *	GetDefinition () const

const G4String &	GetName () const

const G4String &	GetFormatedName () const

G4int	GetAtomsNumber () const

G4MolecularConfiguration *	ExciteMolecule (G4int) const

G4MolecularConfiguration *	IonizeMolecule (G4int) const

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

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

G4MolecularConfiguration *	MoveOneElectron (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 G4ElectronOccupancy *	GetElectronOccupancy () const

G4int	GetCharge () const

void	SetMass (G4double)

G4double	GetMass () const

void	SetLabel (const G4String &)

const G4String &	GetLabel () const

void	Finalize ()

void	UnFinalize ()

void	SetUserID (const G4String &userID)

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	PrintAll ()

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) const

G4MolecularConfiguration *	ChangeConfiguration (int charge) const

void	CheckElectronOccupancy (const char *line) const

void	MakeExceptionIfFinalized ()

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 = 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.

{
  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 = nullptr; // let it here
 
  if(!label.empty())
  {
    SetLabel(label);
  }
 
  fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
 
  fIsFinalized = false;
}

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

Definition at line 470 of file G4MolecularConfiguration.cc.

{
  fMoleculeDefinition = moleculeDef;
 
  fMoleculeID = GetManager()->Insert(moleculeDef,
                                     charge,
                                     this);
  fElectronOccupancy = nullptr;
 
  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 = nullptr;
 
  fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
 
  fIsFinalized = false;
}

◆ G4MolecularConfiguration() [3/5]

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

protected

Definition at line 78 of file G4MolecularConfiguration.cc.

{
  fMoleculeDefinition = moleculeDef;
 
  fLabel = new G4String(label);
 
  fMoleculeID = GetManager()->Insert(moleculeDef,
                                     label,
                                     this);
  fElectronOccupancy = nullptr;
 
  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;
}

◆ G4MolecularConfiguration() [4/5]

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

protected

Definition at line 1393 of file G4MolecularConfiguration.cc.

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

◆ G4MolecularConfiguration() [5/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MolecularConfiguration & )

protected

◆ ~G4MolecularConfiguration()

G4MolecularConfiguration::~G4MolecularConfiguration ( )

protected

Definition at line 507 of file G4MolecularConfiguration.cc.

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

Member Function Documentation

◆ AddDiffCoeffParameterization()

void G4MolecularConfiguration::AddDiffCoeffParameterization ( const G4DiffCoeffParam & para )

inline

Definition at line 572 of file G4MolecularConfiguration.hh.

{
  fDiffParam = para;
}

◆ 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.

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

Referenced by G4Molecule::AddElectron().

◆ ChangeConfiguration() [1/2]

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

protected

Definition at line 524 of file G4MolecularConfiguration.cc.

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

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.

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

◆ CheckElectronOccupancy()

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

protected

Definition at line 788 of file G4MolecularConfiguration.cc.

{
  if (fElectronOccupancy == nullptr)
  {
    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);
  }
}

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

◆ CreateDefaultDiffCoeffParam()

void G4MolecularConfiguration::CreateDefaultDiffCoeffParam ( )

protected

Definition at line 1465 of file G4MolecularConfiguration.cc.

{
  if(!static_cast<bool>(fDiffParam))
  {
    fDiffParam = &G4MolecularConfiguration::ReturnDefaultDiffCoeff;
  }
}

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.

{
  wasAlreadyCreated = false;
  G4MolecularConfiguration* preRegisteredMolConf =
      GetManager()->GetMolecularConfiguration(userIdentifier);
 
  if(preRegisteredMolConf != nullptr)
  {
    if(preRegisteredMolConf->GetDefinition() == molDef)
    {
      wasAlreadyCreated = true;
      return preRegisteredMolConf;
    }
  }
 
  if(molDef->GetGroundStateElectronOccupancy() != nullptr)
  {
    const G4ElectronOccupancy& elecOcc = *molDef
        ->GetGroundStateElectronOccupancy();
    G4MolecularConfiguration* molConf =
        GetManager()->GetMolecularConfiguration(molDef, elecOcc);
 
    if(molConf != nullptr)
    {
      if(molConf->fUserIdentifier.empty())
      {
        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;
    }
    
    // G4cout << "Create molConf for " << molDef->GetName() << G4endl;
    auto  newConf = new G4MolecularConfiguration(molDef,
                                                                    elecOcc);
    newConf->fUserIdentifier = userIdentifier;
 
    GetManager()->AddUserID(userIdentifier, newConf);
 
//      G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
//                                                                newConf);
    return newConf;
  }
  
  return CreateMolecularConfiguration(userIdentifier,
                                      molDef,
                                      molDef->GetName(),
                                      molDef->GetCharge(),
                                      wasAlreadyCreated);
}

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.

{
  assert(label != "");
  wasAlreadyCreated = false;
 
  G4MolecularConfiguration* molConf =
      GetManager()->GetMolecularConfiguration(molDef, label);
  if(molConf != nullptr)
  {
    if((molConf->fLabel != nullptr)
       && *molConf->fLabel == label)
    {
      wasAlreadyCreated = true;
      return molConf;
    }
    if(molConf->fLabel == nullptr)
    {
      wasAlreadyCreated = true;
      molConf->SetLabel(label);
      return molConf;
    }
    if(molConf->fLabel->empty())
    {
      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
  {
    auto  newConf =
      new G4MolecularConfiguration(molDef,
                                   label,
                                   molDef->GetCharge());
    newConf->fUserIdentifier = userIdentifier;
 
    GetManager()->AddUserID(userIdentifier, newConf);
 
//    G4MoleculeTable::Instance()->
//        RecordMolecularConfiguration(userIdentifier, newConf);
    return newConf;
  }
  return molConf;
}

◆ 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.

{
  assert(label != "");
  wasAlreadyCreated = false;
 
  G4MolecularConfiguration* molConf =
      GetManager()->GetMolecularConfiguration(molDef, eOcc);
 
  if(molConf != nullptr)
  {
    if(molConf->GetElectronOccupancy() != nullptr)
    {
      if(*molConf->GetElectronOccupancy() == eOcc)
      {
        if((molConf->fLabel != nullptr) && *molConf->fLabel == label)
        {
          wasAlreadyCreated = true;
          return molConf;
        }
        if(molConf->fLabel == nullptr)
        {
          wasAlreadyCreated = true;
          molConf->SetLabel(label);
          return molConf;
        }
        if(molConf->fLabel->empty())
        {
          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
  {
    auto  newConf =
      new G4MolecularConfiguration(molDef,
                                   eOcc,
                                   label);
    newConf->fUserIdentifier = userIdentifier;
 
    GetManager()->AddUserID(userIdentifier, newConf);
 
//    G4MoleculeTable::Instance()->
//        RecordMolecularConfiguration(userIdentifier, newConf);
    return newConf;
  }
  return molConf;
}

◆ 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.

{
  wasAlreadyCreated = false;
  G4MolecularConfiguration* molConf =
      GetManager()->GetMolecularConfiguration(molDef, charge);
 
  if (molConf != nullptr)
  {
    if(molConf->fLabel == nullptr)
    {
      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->empty() )
    {
      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.empty())
    {
      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;
  }
  
  auto  newConf =
      new G4MolecularConfiguration(molDef, label, charge);
  newConf->fUserIdentifier = userIdentifier;
 
  GetManager()->AddUserID(userIdentifier, newConf);
 
//    G4MoleculeTable::Instance()->RecordMolecularConfiguration(userIdentifier,
//                                                              newConf);
  return newConf;
}

◆ DeleteManager()

void G4MolecularConfiguration::DeleteManager ( )

static

Definition at line 407 of file G4MolecularConfiguration.cc.

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

Referenced by G4DNAChemistryManager::Clear().

◆ DiffCoeffWater()

double G4MolecularConfiguration::DiffCoeffWater ( double temperature_K )

static

Definition at line 1432 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;
}

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.

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

Referenced by G4Molecule::ExciteMolecule().

◆ Finalize()

void G4MolecularConfiguration::Finalize ( )

inline

Definition at line 561 of file G4MolecularConfiguration.hh.

{
  CreateDefaultDiffCoeffParam();
  fIsFinalized = true;
}

◆ FinalizeAll()

void G4MolecularConfiguration::FinalizeAll ( )

static

Definition at line 1511 of file G4MolecularConfiguration.cc.

{
  const std::vector<G4MolecularConfiguration*>& species =
      GetManager()->GetAllSpecies();
 
  for(auto specie : species)
  {
    specie->Finalize();
  }
 
}

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.

{
  return fMoleculeDefinition->GetAtomsNumber();
}

Referenced by G4Molecule::GetAtomsNumber().

◆ GetCharge()

G4int G4MolecularConfiguration::GetCharge ( ) const

inline

Returns the charge of molecule.

Definition at line 518 of file G4MolecularConfiguration.hh.

{
  return fDynCharge;
}

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.

{
  return fDynDecayTime;
}

Referenced by G4Molecule::GetDecayTime().

◆ GetDefinition()

const G4MoleculeDefinition * G4MolecularConfiguration::GetDefinition ( ) const

inline

Definition at line 475 of file G4MolecularConfiguration.hh.

{
  return fMoleculeDefinition;
}

Referenced by G4MoleculeCounter::AddAMoleculeAtTime(), G4Molecule::BuildTrack(), G4Molecule::ChangeConfigurationToLabel(), CreateMolecularConfiguration(), G4Molecule::GetDefinition(), G4MoleculeCounter::RemoveAMoleculeAtTime(), G4MolecularConfiguration::G4MolecularConfigurationManager::RemoveMolecularConfigurationFromTable(), and G4Molecule::SetElectronOccupancy().

◆ GetDiffusionCoefficient() [1/2]

G4double G4MolecularConfiguration::GetDiffusionCoefficient ( ) const

inline

Returns the diffusion coefficient D.

Definition at line 491 of file G4MolecularConfiguration.hh.

{
  return fDynDiffusionCoefficient;
}

Referenced by G4DNAMolecularReactionData::ComputeEffectiveRadius(), G4Molecule::GetDiffusionCoefficient(), G4Molecule::GetDiffusionCoefficient(), G4DNAIRT::GetIndependentReactionTime(), G4DiffusionControlledReactionModel::GetTimeToEncounter(), G4DNAGillespieDirectMethod::PropensityFunction(), G4DNAIRT::Sampling(), ScaleAllDiffusionCoefficientsOnWater(), G4DNAMolecularReactionData::SetReactionType(), and G4DNAMakeReaction::UpdatePositionForReaction().

◆ GetDiffusionCoefficient() [2/2]

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

inline

Definition at line 579 of file G4MolecularConfiguration.hh.

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

◆ GetDissociationChannels()

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

Definition at line 754 of file G4MolecularConfiguration.cc.

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

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.

{
  return fElectronOccupancy;
}

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

◆ GetFakeParticleID()

G4int G4MolecularConfiguration::GetFakeParticleID ( ) const

Definition at line 762 of file G4MolecularConfiguration.cc.

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

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.

{
  return fFormatedName;
}

Referenced by G4Molecule::GetFormatedName().

◆ GetGlobalTemperature()

G4double G4MolecularConfiguration::GetGlobalTemperature ( )

static

Definition at line 1483 of file G4MolecularConfiguration.cc.

{
  return fgTemperature;
}

Referenced by G4DNAChemistryManager::GetCurrentValue(), and G4Molecule::GetDiffusionVelocity().

◆ GetLabel()

const G4String & G4MolecularConfiguration::GetLabel ( ) const

inline

Definition at line 553 of file G4MolecularConfiguration.hh.

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

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

◆ GetManager()

G4MolecularConfiguration::G4MolecularConfigurationManager * G4MolecularConfiguration::GetManager ( )

staticprotected

Definition at line 129 of file G4MolecularConfiguration.cc.

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

◆ GetMass()

G4double G4MolecularConfiguration::GetMass ( ) const

inline

Returns the total mass of the molecule.

Definition at line 529 of file G4MolecularConfiguration.hh.

{
  return fDynMass;
}

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

◆ GetMolecularConfiguration() [1/3]

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

static

Definition at line 952 of file G4MolecularConfiguration.cc.

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

Referenced by G4MoleculeDefinition::AddDecayChannel(), G4Molecule::ChangeConfigurationToLabel(), G4MoleculeTable::GetConfiguration(), G4MoleculeTable::GetConfiguration(), G4MoleculeDefinition::GetConfigurationWithLabel(), and G4MoleculeTableMessenger::SetNewValue().

◆ GetMolecularConfiguration() [2/3]

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

static

Definition at line 1504 of file G4MolecularConfiguration.cc.

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

◆ GetMolecularConfiguration() [3/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration ( int moleculeID )

static

Definition at line 961 of file G4MolecularConfiguration.cc.

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

◆ GetMoleculeID()

G4int G4MolecularConfiguration::GetMoleculeID ( ) const

inline

Definition at line 534 of file G4MolecularConfiguration.hh.

{
  return fMoleculeID;
}

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateStep(), G4DNAMoleculeEncounterStepper::CalculateStep(), and G4Molecule::GetMoleculeID().

◆ GetName()

const G4String & G4MolecularConfiguration::GetName ( ) const

Returns the name of the molecule

Definition at line 687 of file G4MolecularConfiguration.cc.

{
  return fName;
}

Referenced by G4DNAScavengerMaterial::AddAMoleculeAtTime(), G4MoleculeCounter::AddAMoleculeAtTime(), G4DNAMolecularReactionTable::CanReactWith(), G4Molecule::GetName(), G4DNAScavengerMaterial::GetNMoleculesAtTime(), G4DNAScavengerMaterial::GetNumberMoleculePerVolumeUnitForMaterialConf(), G4DNAMolecularReactionTable::GetReactionData(), G4DNAMolecularReactionTable::GetReactionData(), G4DiffusionControlledReactionModel::GetReactionRadius(), G4DNAMolecularReactionTable::GetReativesNData(), G4ChemEquilibrium::Initialize(), IonizeMolecule(), MakeExceptionIfFinalized(), MoveOneElectron(), G4DNAScavengerProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4ChemEquilibrium::PrintInfo(), PrintState(), G4DNAMolecularReactionTable::PrintTable(), G4DNAScavengerMaterial::RemoveAMoleculeAtTime(), G4MoleculeCounter::RemoveAMoleculeAtTime(), RemoveElectron(), G4DNAIRT::Sampling(), G4ChemEquilibrium::SetEquilibrium(), G4DNAScavengerProcess::SetReaction(), and G4DNAUpdateSystemModel::UpdateSystem().

◆ GetNbElectrons()

G4double G4MolecularConfiguration::GetNbElectrons ( ) const

Returns the number of electron.

Definition at line 708 of file G4MolecularConfiguration.cc.

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

Referenced by G4Molecule::GetNbElectrons().

◆ GetNumberOfSpecies()

int G4MolecularConfiguration::GetNumberOfSpecies ( )

static

Definition at line 65 of file G4MolecularConfiguration.cc.

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

Referenced by G4MoleculeTable::GetNumberOfDefinedSpecies().

◆ GetOrCreateMolecularConfiguration() [1/3]

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

static

Definition at line 326 of file G4MolecularConfiguration.cc.

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

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.

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

◆ GetOrCreateMolecularConfiguration() [3/3]

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

static

Definition at line 388 of file G4MolecularConfiguration.cc.

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

◆ GetUserID()

const G4String & G4MolecularConfiguration::GetUserID ( ) const

inline

Definition at line 567 of file G4MolecularConfiguration.hh.

{
  return fUserIdentifier;
}

◆ GetUserIDTable()

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

inlinestatic

Definition at line 166 of file G4MolecularConfiguration.hh.

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

Referenced by G4MoleculeTable::GetConfigurationIterator().

◆ GetVanDerVaalsRadius()

G4double G4MolecularConfiguration::GetVanDerVaalsRadius ( ) const

inline

Definition at line 513 of file G4MolecularConfiguration.hh.

{
  return fDynVanDerVaalsRadius;
}

Referenced by G4Molecule::GetVanDerVaalsRadius(), and G4DNAMolecularReactionData::SetReactionType().

◆ IonizeMolecule()

G4MolecularConfiguration * G4MolecularConfiguration::IonizeMolecule ( G4int IonizedLevel ) const

Method used in Geant4-DNA to ionize water molecules

Definition at line 585 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);
}

Referenced by G4Molecule::IonizeMolecule().

◆ Load()

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

static

Definition at line 1386 of file G4MolecularConfiguration.cc.

{
  return new G4MolecularConfiguration(in);
}

◆ MakeExceptionIfFinalized()

void G4MolecularConfiguration::MakeExceptionIfFinalized ( )

protected

Definition at line 113 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);
  }
}

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.

{
//  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);
}

Referenced by G4Molecule::MoveOneElectron().

◆ operator=()

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

protected

Definition at line 557 of file G4MolecularConfiguration.cc.

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

◆ PrintAll()

void G4MolecularConfiguration::PrintAll ( )

static

Definition at line 1523 of file G4MolecularConfiguration.cc.

{
  const std::vector<G4MolecularConfiguration*>& species =
    GetManager()->GetAllSpecies();
  G4cout<<G4endl;
  G4cout<<"Molecular Config"<<std::setw(25)<<" | Diffusion Coefficient (m2 / s) "<<std::setw(20)<<" | Radius (nm) "<<G4endl;
  G4cout<<"__________________________________________"
            "___________________________________"<<G4endl;
  for(auto specie : species)
  {
    G4cout<<specie->GetName()
           <<std::setw(G4int(30 - specie->GetName().length()))
           <<right<<specie->GetDiffusionCoefficient() * 1.0e3<<std::setw(30)
           <<specie->GetVanDerVaalsRadius()/CLHEP::nm<<G4endl;
    G4cout<<"__________________________________________"
              "___________________________________"<<G4endl;
  }
 
}

Referenced by G4MoleculeTableMessenger::SetNewValue().

◆ PrintState()

void G4MolecularConfiguration::PrintState ( ) const

Display the electronic state of the molecule.

Definition at line 716 of file G4MolecularConfiguration.cc.

{
  G4cout << "-------------- Start Printing State " << GetName()
         << " ---------------" << G4endl;
 
  if (fElectronOccupancy != nullptr)
  {
    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 != nullptr)
  {
    G4cout << "Label :"
           << GetLabel()
           << G4endl;
  }
  G4cout  << "-------------- End Of State " << GetName()
          << " -----------------------" << G4endl;
}

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.

{
//  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);
}

Referenced by G4Molecule::RemoveElectron().

◆ ReturnDefaultDiffCoeff()

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

staticprotected

Definition at line 70 of file G4MolecularConfiguration.cc.

{
  return molConf->fDynDiffusionCoefficient;
}

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

◆ ScaleAllDiffusionCoefficientsOnWater()

void G4MolecularConfiguration::ScaleAllDiffusionCoefficientsOnWater ( double temperature_K )

staticprotected

Definition at line 1443 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);
  };
}

Referenced by SetGlobalTemperature().

◆ Serialize()

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

Definition at line 1336 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);
}

◆ SetDecayTime()

void G4MolecularConfiguration::SetDecayTime ( G4double dynDecayTime )

inline

Set the decay time of the molecule.

Definition at line 496 of file G4MolecularConfiguration.hh.

{
  MakeExceptionIfFinalized();
  fDynDecayTime = dynDecayTime;
}

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.

{
  MakeExceptionIfFinalized();
  fDynDiffusionCoefficient = dynDiffusionCoefficient;
}

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

◆ SetGlobalTemperature()

void G4MolecularConfiguration::SetGlobalTemperature ( G4double temperature )

static

Definition at line 1475 of file G4MolecularConfiguration.cc.

{
  ScaleAllDiffusionCoefficientsOnWater(temperature);
  fgTemperature = temperature;
}

Referenced by G4DNAChemistryManager::SetGlobalTemperature().

◆ SetLabel()

void G4MolecularConfiguration::SetLabel ( const G4String & label )

inline

Definition at line 539 of file G4MolecularConfiguration.hh.

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

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.

{
  MakeExceptionIfFinalized();
  fDynMass = aMass;
}

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

◆ SetUserID()

void G4MolecularConfiguration::SetUserID ( const G4String & userID )

Definition at line 1423 of file G4MolecularConfiguration.cc.

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

◆ SetVanDerVaalsRadius()

void G4MolecularConfiguration::SetVanDerVaalsRadius ( G4double dynVanDerVaalsRadius )

inline

The Van Der Valls Radius of the molecule

Definition at line 507 of file G4MolecularConfiguration.hh.

{
  MakeExceptionIfFinalized();
  fDynVanDerVaalsRadius = dynVanDerVaalsRadius;
}

Referenced by G4ChemDissociationChannels_option1::ConstructMolecule().

◆ UnFinalize()

void G4MolecularConfiguration::UnFinalize ( )

inline

Definition at line 585 of file G4MolecularConfiguration.hh.

{
  fIsFinalized = false;
}

◆ Unserialize()

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

Definition at line 1358 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);
}