#include <G4MolecularConfiguration.hh>

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

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

G4MolecularConfiguration *	ChangeConfiguration (int charge) const

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

◆ G4DiffCoeffParam

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

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

◆ G4MolecularConfiguration() [2/5]

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

protected

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

◆ G4MolecularConfiguration() [3/5]

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

protected

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

◆ G4MolecularConfiguration() [4/5]

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

protected

Definition at line 1443 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() [5/5]

G4MolecularConfiguration::G4MolecularConfiguration ( const G4MolecularConfiguration & )

protected

◆ ~G4MolecularConfiguration()

G4MolecularConfiguration::~G4MolecularConfiguration ( )

protected

Definition at line 526 of file G4MolecularConfiguration.cc.

{
  if (fgManager) 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 581 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 635 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 543 of file G4MolecularConfiguration.cc.

{
  G4MolecularConfiguration* output =
      GetManager()->GetMolecularConfiguration(fMoleculeDefinition,
                                              newElectronOccupancy);
 
  if (!output)
  {
    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 561 of file G4MolecularConfiguration.cc.

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

◆ CheckElectronOccupancy()

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

protected

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

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

◆ CreateDefaultDiffCoeffParam()

void G4MolecularConfiguration::CreateDefaultDiffCoeffParam ( )

protected

Definition at line 1515 of file G4MolecularConfiguration.cc.

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

Referenced by Finalize().

◆ CreateMolecularConfiguration() [1/4]

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

static

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

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

◆ CreateMolecularConfiguration() [2/4]

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

static

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

◆ CreateMolecularConfiguration() [3/4]

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

static

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

◆ CreateMolecularConfiguration() [4/4]

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

static

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

◆ DeleteManager()

void G4MolecularConfiguration::DeleteManager ( )

static

Definition at line 426 of file G4MolecularConfiguration.cc.

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

Referenced by G4DNAChemistryManager::Clear().

◆ DiffCoeffWater()

double G4MolecularConfiguration::DiffCoeffWater ( double temperature_K )

static

Definition at line 1482 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 587 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 570 of file G4MolecularConfiguration.hh.

{
  CreateDefaultDiffCoeffParam();
  fIsFinalized = true;
}

◆ FinalizeAll()

void G4MolecularConfiguration::FinalizeAll ( )

static

Definition at line 1561 of file G4MolecularConfiguration.cc.

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

Referenced by G4MoleculeTable::Finalize().

◆ GetAtomsNumber()

G4int G4MolecularConfiguration::GetAtomsNumber ( ) const

Returns the nomber of atoms compouning the molecule

Definition at line 736 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 527 of file G4MolecularConfiguration.hh.

{
  return fDynCharge;
}

Referenced by G4Molecule::GetCharge().

◆ GetDecayTime()

G4double G4MolecularConfiguration::GetDecayTime ( ) const

inline

Returns the decay time of the molecule.

Definition at line 511 of file G4MolecularConfiguration.hh.

{
  return fDynDecayTime;
}

Referenced by G4Molecule::GetDecayTime().

◆ GetDefinition()

const G4MoleculeDefinition * G4MolecularConfiguration::GetDefinition ( ) const

inline

Definition at line 484 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 500 of file G4MolecularConfiguration.hh.

{
  return fDynDiffusionCoefficient;
}

Referenced by G4Molecule::GetDiffusionCoefficient(), G4DNAIRT::GetIndependentReactionTime(), G4DNAIRT::Sampling(), ScaleAllDiffusionCoefficientsOnWater(), and G4DNAMolecularReactionData::SetReactionType().

◆ GetDiffusionCoefficient() [2/2]

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

inline

Definition at line 588 of file G4MolecularConfiguration.hh.

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

◆ GetDissociationChannels()

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

Definition at line 789 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 489 of file G4MolecularConfiguration.hh.

{
  return fElectronOccupancy;
}

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

◆ GetFakeParticleID()

G4int G4MolecularConfiguration::GetFakeParticleID ( ) const

Definition at line 797 of file G4MolecularConfiguration.cc.

{
  if(fMoleculeDefinition) return fMoleculeDefinition->GetPDGEncoding();
  else 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 721 of file G4MolecularConfiguration.cc.

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

Referenced by G4Molecule::GetFormatedName().

◆ GetGlobalTemperature()

G4double G4MolecularConfiguration::GetGlobalTemperature ( )

static

Definition at line 1533 of file G4MolecularConfiguration.cc.

{
  return fgTemperature;
}

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

◆ GetLabel()

const G4String & G4MolecularConfiguration::GetLabel ( ) const

inline

Definition at line 562 of file G4MolecularConfiguration.hh.

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

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

◆ GetManager()

G4MolecularConfiguration::G4MolecularConfigurationManager * G4MolecularConfiguration::GetManager ( )

staticprotected

Definition at line 130 of file G4MolecularConfiguration.cc.

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

Referenced by ChangeConfiguration(), CreateMolecularConfiguration(), FinalizeAll(), G4MolecularConfiguration(), GetMolecularConfiguration(), GetNumberOfSpecies(), GetOrCreateMolecularConfiguration(), GetUserIDTable(), and SetUserID().

◆ GetMass()

G4double G4MolecularConfiguration::GetMass ( ) const

inline

Returns the total mass of the molecule.

Definition at line 538 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 988 of file G4MolecularConfiguration.cc.

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

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

◆ GetMolecularConfiguration() [2/3]

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

static

Definition at line 1554 of file G4MolecularConfiguration.cc.

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

◆ GetMolecularConfiguration() [3/3]

G4MolecularConfiguration * G4MolecularConfiguration::GetMolecularConfiguration ( int moleculeID )

static

Definition at line 997 of file G4MolecularConfiguration.cc.

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

◆ GetMoleculeID()

G4int G4MolecularConfiguration::GetMoleculeID ( ) const

inline

Definition at line 543 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 706 of file G4MolecularConfiguration.cc.

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

Referenced by G4MoleculeCounter::AddAMoleculeAtTime(), G4DNAMolecularReactionTable::CanReactWith(), G4Molecule::GetName(), G4DNAMolecularReactionTable::GetReactionData(), G4DNAMolecularReactionTable::GetReativesNData(), IonizeMolecule(), MakeExceptionIfFinalized(), MoveOneElectron(), PrintState(), G4DNAMolecularReactionTable::PrintTable(), G4MoleculeCounter::RemoveAMoleculeAtTime(), RemoveElectron(), and G4DNAIRT::Sampling().

◆ GetNbElectrons()

G4double G4MolecularConfiguration::GetNbElectrons ( ) const

Returns the number of electron.

Definition at line 743 of file G4MolecularConfiguration.cc.

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

Referenced by G4Molecule::GetNbElectrons().

◆ GetNumberOfSpecies()

int G4MolecularConfiguration::GetNumberOfSpecies ( )

static

Definition at line 66 of file G4MolecularConfiguration.cc.

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

Referenced by G4MoleculeTable::GetNumberOfDefinedSpecies().

◆ GetOrCreateMolecularConfiguration() [1/3]

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

static

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

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

◆ GetOrCreateMolecularConfiguration() [2/3]

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

static

Definition at line 381 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 405 of file G4MolecularConfiguration.cc.

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

◆ GetUserID()

const G4String & G4MolecularConfiguration::GetUserID ( ) const

inline

Definition at line 576 of file G4MolecularConfiguration.hh.

{
  return fUserIdentifier;
}

◆ GetUserIDTable()

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

inlinestatic

Definition at line 169 of file G4MolecularConfiguration.hh.

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

Referenced by G4MoleculeTable::GetConfigurationIterator().

◆ GetVanDerVaalsRadius()

G4double G4MolecularConfiguration::GetVanDerVaalsRadius ( ) const

inline

Definition at line 522 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 604 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 1436 of file G4MolecularConfiguration.cc.

{
  return new G4MolecularConfiguration(in);
}

◆ MakeExceptionIfFinalized()

void G4MolecularConfiguration::MakeExceptionIfFinalized ( )

protected

Definition at line 114 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 677 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 576 of file G4MolecularConfiguration.cc.

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

◆ PrintState()

void G4MolecularConfiguration::PrintState ( ) const

Display the electronic state of the molecule.

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

Referenced by 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 648 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 71 of file G4MolecularConfiguration.cc.

{
  return molConf->fDynDiffusionCoefficient;
}

Referenced by CreateDefaultDiffCoeffParam(), and G4MolecularConfiguration().

◆ ScaleAllDiffusionCoefficientsOnWater()

void G4MolecularConfiguration::ScaleAllDiffusionCoefficientsOnWater ( double temperature_K )

staticprotected

Definition at line 1493 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 1386 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 505 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 494 of file G4MolecularConfiguration.hh.

{
  MakeExceptionIfFinalized();
  fDynDiffusionCoefficient = dynDiffusionCoefficient;
}

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

◆ SetGlobalTemperature()

void G4MolecularConfiguration::SetGlobalTemperature ( G4double temperature )

static

Definition at line 1525 of file G4MolecularConfiguration.cc.

{
  ScaleAllDiffusionCoefficientsOnWater(temperature);
  fgTemperature = temperature;
}

Referenced by G4DNAChemistryManager::SetGlobalTemperature().

◆ SetLabel()

void G4MolecularConfiguration::SetLabel ( const G4String & label )

inline

Definition at line 548 of file G4MolecularConfiguration.hh.

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

Referenced by CreateMolecularConfiguration(), and G4MolecularConfiguration().

◆ SetMass()

void G4MolecularConfiguration::SetMass ( G4double aMass )

inline

Set the total mass of the molecule.

Definition at line 532 of file G4MolecularConfiguration.hh.

{
  MakeExceptionIfFinalized();
  fDynMass = aMass;
}

Referenced by G4EmDNAChemistry::ConstructMolecule(), G4EmDNAChemistry_option1::ConstructMolecule(), G4EmDNAChemistry_option3::ConstructMolecule(), and G4EmDNAChemistry_option2::ConstructMolecule().

◆ SetUserID()

void G4MolecularConfiguration::SetUserID ( const G4String & userID )

protected

Definition at line 1473 of file G4MolecularConfiguration.cc.

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

Referenced by GetOrCreateMolecularConfiguration().

◆ SetVanDerVaalsRadius()

void G4MolecularConfiguration::SetVanDerVaalsRadius ( G4double dynVanDerVaalsRadius )

inline

The Van Der Valls Radius of the molecule

Definition at line 516 of file G4MolecularConfiguration.hh.

{
  MakeExceptionIfFinalized();
  fDynVanDerVaalsRadius = dynVanDerVaalsRadius;
}

Referenced by G4EmDNAChemistry_option3::ConstructMolecule().

◆ Unserialize()

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

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