G4MolecularConfiguration::G4MolecularConfigurationManager Class Reference

#include <G4MolecularConfiguration.hh>

Public Member Functions
	G4MolecularConfigurationManager ()
	~G4MolecularConfigurationManager ()
int	GetNumberOfCreatedSpecies ()
G4int	Insert (const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc, G4MolecularConfiguration *molConf)
G4int	Insert (const G4MoleculeDefinition *molDef, int charge, G4MolecularConfiguration *molConf)
G4int	Insert (const G4MoleculeDefinition *molDef, const G4String &label, G4MolecularConfiguration *molConf)
void	AddUserID (const G4String &name, G4MolecularConfiguration *molecule)
void	RecordNewlyLabeledConfiguration (G4MolecularConfiguration *molConf)
const G4ElectronOccupancy *	FindCommonElectronOccupancy (const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)
G4MolecularConfiguration *	GetMolecularConfiguration (const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)
G4MolecularConfiguration *	GetMolecularConfiguration (const G4MoleculeDefinition *molDef, int charge)
G4MolecularConfiguration *	GetMolecularConfiguration (const G4MoleculeDefinition *molDef, const G4String &label)
G4MolecularConfiguration *	GetMolecularConfiguration (int moleculeID)
G4MolecularConfiguration *	GetMolecularConfiguration (const G4String &userID)
G4MolecularConfiguration *	GetOrCreateMolecularConfiguration (const G4MoleculeDefinition *molDef, const G4ElectronOccupancy &eOcc)
G4MolecularConfiguration *	GetOrCreateMolecularConfiguration (const G4MoleculeDefinition *molDef, int charge)
void	RemoveMolecularConfigurationFromTable (G4MolecularConfiguration *)
const std::vector< G4MolecularConfiguration * > &	GetAllSpecies ()
std::map< G4String, G4MolecularConfiguration * > &	GetUserIDTable ()

Static Public Attributes
static G4Mutex	fManagerCreationMutex

Detailed Description

Definition at line 342 of file G4MolecularConfiguration.hh.

Constructor & Destructor Documentation

G4MolecularConfigurationManager()

G4MolecularConfiguration::G4MolecularConfigurationManager::G4MolecularConfigurationManager ( )

inline

Definition at line 345 of file G4MolecularConfiguration.hh.

                                      :
        fMoleculeCreationMutex()
    {
      fLastMoleculeID = -1;
    }

~G4MolecularConfigurationManager()

G4MolecularConfiguration::G4MolecularConfigurationManager::~G4MolecularConfigurationManager

(

)

Definition at line 148 of file G4MolecularConfiguration.cc.

{
//  G4cout << "Does G4AllocatorList exists= ";
//  G4cout << (G4AllocatorList::GetAllocatorListIfExist() ? "true":"false")
//      << G4endl;
 
  G4MolecularConfigurationManager::MolElectronConfTable::iterator it1;
  G4MolecularConfigurationManager::ElectronOccupancyTable::
    iterator it2;
 
  for (it1 = fElecOccTable.begin(); it1 != fElecOccTable.end(); it1++)
  {
    for (it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
    {
      if (it2->second)
      {
        delete it2->second;
      }
    }
  }
  fElecOccTable.clear();
  fgManager = 0;
}

Member Function Documentation

AddUserID()

void G4MolecularConfiguration::G4MolecularConfigurationManager::AddUserID	(	const G4String &	name,
		G4MolecularConfiguration *	molecule
	)

Definition at line 852 of file G4MolecularConfiguration.cc.

{
  UserIDTable::iterator it = fUserIDTable.find(userID);
 
  if(it == fUserIDTable.end())
  {
    fUserIDTable[userID] = molecule;
  }
  else if(molecule != it->second)
  {
    // TODO improve exception
    // exception
    G4ExceptionDescription description;
    description << "The user identifier " << userID
                << " was already given in another configuration in the table"
                << G4endl;
  G4Exception("G4MolecularConfiguration::G4MolecularConfigurationManager::AddUserID",
                "CONF_ALREADY_RECORDED",
                FatalException,
                description);
  }
}

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

FindCommonElectronOccupancy()

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

Definition at line 215 of file G4MolecularConfiguration.cc.

{
  //G4AutoLock lock(&fMoleculeCreationMutex);
 
  MolElectronConfTable::iterator it1 = fElecOccTable.find(molDef);
 
  if(it1 == fElecOccTable.end())
  {
    // TODO = handle exception ?
    return 0;
  }
 
  ElectronOccupancyTable& table2 = it1->second;
  ElectronOccupancyTable::iterator it2 = table2.find(eOcc);
 
  //lock.unlock();
 
  if (it2 == table2.end())
  {
    // TODO = handle exception ?
    return 0;
  }
 
  return &(it2->first);
}

Referenced by G4MolecularConfiguration::G4MolecularConfiguration().

GetAllSpecies()

const std::vector< G4MolecularConfiguration * > & G4MolecularConfiguration::G4MolecularConfigurationManager::GetAllSpecies ( )

inline

Definition at line 410 of file G4MolecularConfiguration.hh.

    {
      return fMolConfPerID;
    }

Referenced by G4MolecularConfiguration::FinalizeAll(), and G4MolecularConfiguration::PrintAll().

GetMolecularConfiguration() [1/5]

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

Definition at line 246 of file G4MolecularConfiguration.cc.

{
  MolElectronConfTable::iterator it1 = fElecOccTable.find(molDef);
 
  if(it1 == fElecOccTable.end()) return 0;
 
  ElectronOccupancyTable& table2 = it1->second;
  ElectronOccupancyTable::iterator it = table2.find(eOcc);
 
  if(it == table2.end())
  {
    return 0;
  }
  else
  {
    return it->second;
  }
 
  return 0;
}

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

GetMolecularConfiguration() [2/5]

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

Definition at line 902 of file G4MolecularConfiguration.cc.

{
  //G4AutoLock lock(&fMoleculeCreationMutex);
 
  MolLabelConfTable::iterator it1 = fLabelTable.find(molDef);
 
  if(it1 == fLabelTable.end()) return 0;
 
  LabelTable& table2 = it1->second;
 
  LabelTable::iterator it2 = table2.find(label);
 
  //lock.unlock();
 
  if(it2 == table2.end()) return 0;
  return it2->second;
}

GetMolecularConfiguration() [3/5]

G4MolecularConfiguration * G4MolecularConfiguration::G4MolecularConfigurationManager::GetMolecularConfiguration	(	const G4MoleculeDefinition *	molDef,
		int	charge
	)

Definition at line 306 of file G4MolecularConfiguration.cc.

{
  //G4AutoLock lock(&fMoleculeCreationMutex);
 
  MolChargeConfTable::iterator it1 = fChargeTable.find(molDef);
 
  if(it1 == fChargeTable.end()) return 0;
 
  ChargeTable& table2 = it1->second;
  ChargeTable::iterator it = table2.find(charge);
 
  if(it == table2.end())
  {
    return 0;
  }
  else
  {
    return it->second;
  }
 
  return 0;
 
  //lock.unlock();
  return 0;
}

GetMolecularConfiguration() [4/5]

G4MolecularConfiguration * G4MolecularConfiguration::G4MolecularConfigurationManager::GetMolecularConfiguration

(

const G4String &

userID

)

Definition at line 1525 of file G4MolecularConfiguration.cc.

{
  for(auto it : fMolConfPerID)
  {
    if(it->GetUserID() == userID) return it;
  }
  return 0;
}

GetMolecularConfiguration() [5/5]

G4MolecularConfiguration * G4MolecularConfiguration::G4MolecularConfigurationManager::GetMolecularConfiguration

(

int

moleculeID

)

Definition at line 925 of file G4MolecularConfiguration.cc.

{
  if(moleculeID > (int) fMolConfPerID.size() ||
     moleculeID < 0) return 0;
 
  return fMolConfPerID[moleculeID];
}

GetNumberOfCreatedSpecies()

int G4MolecularConfiguration::G4MolecularConfigurationManager::GetNumberOfCreatedSpecies ( )

inline

Definition at line 352 of file G4MolecularConfiguration.hh.

    {
      return fLastMoleculeID+1;
    }

Referenced by G4MolecularConfiguration::GetNumberOfSpecies().

GetOrCreateMolecularConfiguration() [1/2]

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

Definition at line 1302 of file G4MolecularConfiguration.cc.

{
  MolElectronConfTable::iterator it1 = fElecOccTable.find(molDef);
 
  if(it1 == fElecOccTable.end())
  {
    return new G4MolecularConfiguration(molDef, eOcc);
  }
 
  ElectronOccupancyTable& table2 = it1->second;
  ElectronOccupancyTable::iterator it = table2.find(eOcc);
 
  if(it == table2.end())
  {
    G4MolecularConfiguration* molConf =
        new G4MolecularConfiguration(molDef, eOcc);
//    molConf->Finalize();
    return molConf;
  }
  else
  {
    return it->second;
  }
 
  return 0;
}

Referenced by G4MolecularConfiguration::GetOrCreateMolecularConfiguration().

GetOrCreateMolecularConfiguration() [2/2]

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

Definition at line 1334 of file G4MolecularConfiguration.cc.

{
  MolChargeConfTable::iterator it1 = fChargeTable.find(molDef);
 
  if(it1 == fChargeTable.end())
  {
    G4AutoLock lock(&fMoleculeCreationMutex);
 
    G4MolecularConfiguration* newConf = new G4MolecularConfiguration(molDef, charge);
    return newConf ;
  }
 
  ChargeTable& table2 = it1->second;
  ChargeTable::iterator it = table2.find(charge);
 
  if(it == table2.end())
  {
    G4AutoLock lock(&fMoleculeCreationMutex);
 
    G4MolecularConfiguration* newConf =
        new G4MolecularConfiguration(molDef, charge);
//    newConf->Finalize();
    return newConf ;
  }
  else
  {
    return it->second;
  }
 
  return 0;
}

GetUserIDTable()

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

inline

Definition at line 415 of file G4MolecularConfiguration.hh.

    {
      return fUserIDTable;
    }

Referenced by G4MolecularConfiguration::GetUserIDTable().

Insert() [1/3]

G4int G4MolecularConfiguration::G4MolecularConfigurationManager::Insert	(	const G4MoleculeDefinition *	molDef,
		const G4ElectronOccupancy &	eOcc,
		G4MolecularConfiguration *	molConf
	)

Definition at line 175 of file G4MolecularConfiguration.cc.

{
  //G4AutoLock lock(&fMoleculeCreationMutex);
 
  ElectronOccupancyTable& table2 = fElecOccTable[molDef];
  ElectronOccupancyTable::iterator it = table2.find(eOcc);
 
  if(it == table2.end())
  {
    table2[eOcc] = molConf;
  }
  else
  {
    G4ExceptionDescription errMsg;
    errMsg << "The same molecular configuration seemed to be recorded twice";
    G4Exception("G4MolecularConfigurationManager::"
                "SetMolecularConfiguration(const G4MoleculeDefinition* molDef,"
                "const G4ElectronOccupancy& eOcc,"
                "G4MolecularConfiguration* molConf)",
                "",
                FatalException,
                errMsg
                );
  }
 
  fLastMoleculeID++;
 
  fMolConfPerID.push_back(molConf);
 
  //lock.unlock();
  return fLastMoleculeID;
}

Referenced by G4MolecularConfiguration::G4MolecularConfiguration().

Insert() [2/3]

G4int G4MolecularConfiguration::G4MolecularConfigurationManager::Insert	(	const G4MoleculeDefinition *	molDef,
		const G4String &	label,
		G4MolecularConfiguration *	molConf
	)

Definition at line 937 of file G4MolecularConfiguration.cc.

{
  G4AutoLock lock(&fMoleculeCreationMutex);
  LabelTable& tmpMap = fLabelTable[molDef];
  LabelTable::iterator it = tmpMap.find(label);
 
  if(it == tmpMap.end())
  {
    fLastMoleculeID++;
    tmpMap[label] = molConf;
    lock.unlock();
  }
  else
  {
    lock.unlock();
    G4ExceptionDescription errMsg;
    errMsg << "The same molecular configuration seemed to be recorded twice";
    G4Exception("G4MolecularConfigurationManager::"
                "SetMolecularConfiguration(const G4MoleculeDefinition* molDef,"
                "const G4String& label,"
                "G4MolecularConfiguration* molConf)",
                "", FatalException, errMsg);
  }
 
  fMolConfPerID.push_back(molConf);
 
  return fLastMoleculeID;
}

Insert() [3/3]

G4int G4MolecularConfiguration::G4MolecularConfigurationManager::Insert	(	const G4MoleculeDefinition *	molDef,
		int	charge,
		G4MolecularConfiguration *	molConf
	)

Definition at line 271 of file G4MolecularConfiguration.cc.

{
 
  //G4AutoLock lock(&fMoleculeCreationMutex);
  ChargeTable& table2 = fChargeTable[molDef];
  ChargeTable::iterator it = table2.find(charge);
 
  if(it == table2.end())
  {
    table2[charge] = molConf;
  }
  else
  {
    //lock.unlock();
    G4ExceptionDescription errMsg;
    errMsg << "The same molecular configuration seemed to be recorded twice";
    G4Exception("G4MolecularConfigurationManager::"
                "SetMolecularConfiguration(const G4MoleculeDefinition* molDef,"
                "int charge,"
                "G4MolecularConfiguration* molConf)",
                "", FatalException, errMsg);
  }
 
  fLastMoleculeID++;
  fMolConfPerID.push_back(molConf);
  //lock.unlock();
  return fLastMoleculeID;
}

RecordNewlyLabeledConfiguration()

void G4MolecularConfiguration::G4MolecularConfigurationManager::RecordNewlyLabeledConfiguration

(

G4MolecularConfiguration *

molConf

)

Definition at line 825 of file G4MolecularConfiguration.cc.

{
  //G4AutoLock lock(&fMoleculeCreationMutex);
 
  LabelTable& tmpMap = fLabelTable[molConf->fMoleculeDefinition];
 
  LabelTable::iterator it = tmpMap.find(*molConf->fLabel);
 
  if(it == tmpMap.end())
  {
    tmpMap[*(molConf->fLabel)] = molConf;
  }
  else
  {
    G4ExceptionDescription errMsg;
    errMsg << "The same molecular configuration seemed to be recorded twice";
    G4Exception("G4MolecularConfigurationManager::"
                "SetMolecularConfiguration(const G4MoleculeDefinition* molDef,"
                "const G4String& label,"
                "G4MolecularConfiguration* molConf)",
                "", FatalException, errMsg);
  }
 
  //lock.unlock();
}

Referenced by G4MolecularConfiguration::G4MolecularConfiguration(), and G4MolecularConfiguration::SetLabel().

RemoveMolecularConfigurationFromTable()

void G4MolecularConfiguration::G4MolecularConfigurationManager::RemoveMolecularConfigurationFromTable

(

G4MolecularConfiguration *

configuration

)

Definition at line 878 of file G4MolecularConfiguration.cc.

{
  MolElectronConfTable::iterator it1 =
      fElecOccTable.find(configuration->GetDefinition());
  MolElectronConfTable::iterator end = fElecOccTable.end();
 
  if (it1 == end) return;
 
  std::map<G4ElectronOccupancy, G4MolecularConfiguration*, comparator>::
    iterator it2 =
      it1->second.find(*configuration->GetElectronOccupancy());
 
  if (it2 == it1->second.end()) return;
 
  it2->second = 0;
//  it1->second.erase(it2);
 
  configuration->fElectronOccupancy = 0;
}

Referenced by G4MolecularConfiguration::~G4MolecularConfiguration().

Member Data Documentation

fManagerCreationMutex

G4Mutex MolecularConfigurationManager::fManagerCreationMutex

static

Definition at line 406 of file G4MolecularConfiguration.hh.

Referenced by G4MolecularConfiguration::DeleteManager(), and G4MolecularConfiguration::GetManager().

---

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

• G4MolecularConfiguration.hh
• G4MolecularConfiguration.cc