#include <G4DNAChemistryManager.hh>

Inheritance diagram for G4DNAChemistryManager:

Public Member Functions
G4bool	Notify (G4ApplicationState requestedState) override

void	SetNewValue (G4UIcommand *, G4String) override

G4String	GetCurrentValue (G4UIcommand *pCommand) override

G4bool	IsChemistryActivated ()

void	SetChemistryActivation (G4bool)

void	SetChemistryList (G4VUserChemistryList &)

void	SetChemistryList (std::unique_ptr< G4VUserChemistryList >)

void	SetChemistryList (G4VUserChemistryList *)

void	Deregister (G4VUserChemistryList &)

void	Initialize ()

void	Run ()

void	Clear ()

void	SetGun (G4ITGun *pChemSpeciesGun)
	Inject custom species to the simulation.

void	SetPhysChemIO (std::unique_ptr< G4VPhysChemIO > pPhysChemIO)

void	SetVerbose (G4int verbose)

void	UseAsStandalone (G4bool flag)

G4bool	IsCounterResetWhenRunEnds () const

void	ResetCounterWhenRunEnds (G4bool resetCounterWhenRunEnds)

void	ForceMasterReinitialization ()

void	TagThreadForReinitialization ()

void	ForceThreadReinitialization ()

void	ForceRebuildingPhysicsTable ()

void	WriteInto (const G4String &, std::ios_base::openmode mode=std::ios_base::out)

void	AddEmptyLineInOutputFile ()

void	CloseFile ()

void	CreateWaterMolecule (ElectronicModification, G4int, const G4Track *)

void	CreateSolvatedElectron (const G4Track , G4ThreeVector pFinalPosition=nullptr)

void	PushMolecule (std::unique_ptr< G4Molecule > pMolecule, G4double time, const G4ThreeVector &position, G4int parentID)

Public Member Functions inherited from G4UImessenger
	G4UImessenger ()

	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

virtual	~G4UImessenger ()

virtual G4String	GetCurrentValue (G4UIcommand *command)

virtual void	SetNewValue (G4UIcommand *command, G4String newValue)

G4bool	operator== (const G4UImessenger &messenger) const

G4bool	operator!= (const G4UImessenger &messenger) const

G4bool	CommandsShouldBeInMaster () const

Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)

virtual	~G4VStateDependent ()

G4bool	operator== (const G4VStateDependent &right) const

G4bool	operator!= (const G4VStateDependent &right) const

virtual G4bool	Notify (G4ApplicationState requestedState)=0

Static Public Member Functions
static G4DNAChemistryManager *	Instance ()

static G4DNAChemistryManager *	GetInstanceIfExists ()

static void	DeleteInstance ()

static G4bool	IsActivated ()

Protected Member Functions
	~G4DNAChemistryManager () override

void	HandleStandaloneInitialization ()

void	PushTrack (G4Track *)

void	SetGlobalTemperature (G4double temperatureKelvin)

G4DNAWaterExcitationStructure *	GetExcitationLevel ()

G4DNAWaterIonisationStructure *	GetIonisationLevel ()

void	InitializeFile ()

void	InitializeMaster ()

void	InitializeThread ()

void	InitializeThreadSharedData ()

	G4DNAChemistryManager ()

Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)

G4String	DtoS (G4double a)

G4String	BtoS (G4bool b)

G4int	StoI (G4String s)

G4long	StoL (G4String s)

G4double	StoD (G4String s)

G4bool	StoB (G4String s)

void	AddUIcommand (G4UIcommand *newCommand)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

Additional Inherited Members
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Detailed Description

WARNING: THIS CLASS IS A PROTOTYPE G4DNAChemistryManager is called from the physics models. It creates the water molecules and the solvated electrons and and send them to G4ITStepManager to be treated in the chemistry stage. For this, the fActiveChemistry flag needs to be on. It is also possible to give already molecule's pointers already built. G4DNAChemistryManager will then be in charge of creating the track and loading it to the IT system. The user can also ask to create a file containing a information about the creation of water molecules and solvated electrons.

Definition at line 87 of file G4DNAChemistryManager.hh.

Constructor & Destructor Documentation

◆ ~G4DNAChemistryManager()

G4DNAChemistryManager::~G4DNAChemistryManager ( )

overrideprotected

Definition at line 164 of file G4DNAChemistryManager.cc.

{
    Clear();
    fgInstance = nullptr;
}

◆ G4DNAChemistryManager()

G4DNAChemistryManager::G4DNAChemistryManager ( )

protected

Definition at line 101 of file G4DNAChemistryManager.cc.

        : G4UImessenger()
        , G4VStateDependent()
        , fpChemDNADirectory(new G4UIdirectory("/chem/"))
        , fpActivateChem(new G4UIcmdWithABool("/chem/activate", this))
        , fpRunChem(new G4UIcmdWithAnInteger("/chem/run", this))
        , fpSkipReactionsFromChemList(new G4UIcmdWithoutParameter("/chem/skipReactionsFromChemList", this))
        , fpScaleForNewTemperature(new G4UIcmdWithADoubleAndUnit("/chem/temperature", this))
        , fpInitChem(new G4UIcmdWithoutParameter("/chem/init", this))
        , fActiveChemistry(false)
        , fMasterInitialized(false)
        , fForceThreadReinitialization(false)
        , fpExcitationLevel(nullptr)
        , fpIonisationLevel(nullptr)
        , fpUserChemistryList(nullptr)
        , fOwnChemistryList(false)
        , fUseInStandalone(false)
        , fPhysicsTableBuilt(false)
        , fSkipReactions(false)
        , fGeometryClosed(false)
        , fVerbose(0)
        , fResetCounterWhenRunEnds(true)
{
    fpRunChem->SetParameterName("Number of runs to execute for the chemistry module"
                                "(this works when used in standalone", true, true);
    fpRunChem->SetDefaultValue(1);
    fpScaleForNewTemperature->SetUnitCategory("Temperature");
}

Referenced by Instance().

Member Function Documentation

◆ AddEmptyLineInOutputFile()

void G4DNAChemistryManager::AddEmptyLineInOutputFile ( )

Definition at line 564 of file G4DNAChemistryManager.cc.

{
    if (fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO->AddEmptyLineInOutputFile();
    }
}

◆ Clear()

void G4DNAChemistryManager::Clear ( )

Definition at line 172 of file G4DNAChemistryManager.cc.

{
    fpIonisationLevel.reset();
    fpExcitationLevel.reset();
 
    if (fpUserChemistryList)
    {
        Deregister(*fpUserChemistryList);
    }
 
    fpChemDNADirectory.reset();
    fpActivateChem.reset();
    fpRunChem.reset();
 
    fpSkipReactionsFromChemList.reset();
    fpInitChem.reset();
 
    if (fpThreadData != nullptr)
    {
        delete fpThreadData;
        fpThreadData = nullptr;
    }
 
    G4DNAMolecularReactionTable::DeleteInstance();
    G4MolecularConfiguration::DeleteManager();
    G4VMoleculeCounter::DeleteInstance();
}

Referenced by Notify(), and ~G4DNAChemistryManager().

◆ CloseFile()

void G4DNAChemistryManager::CloseFile ( )

Close the file specified with WriteInto

Definition at line 574 of file G4DNAChemistryManager.cc.

{
    if (fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO->CloseFile();
    }
}

Referenced by Run().

◆ CreateSolvatedElectron()

void G4DNAChemistryManager::CreateSolvatedElectron	(	const G4Track *	pIncomingTrack,
		G4ThreeVector *	pFinalPosition = `nullptr`
	)

This method should be used by the physics model of the ElectronSolvatation process.

Definition at line 662 of file G4DNAChemistryManager.cc.

{
    if (fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO->CreateSolvatedElectron(pIncomingTrack,
                                                           pFinalPosition);
    }
 
    if (fActiveChemistry)
    {
        PushMolecule(std::unique_ptr<G4Molecule>(new G4Molecule(G4Electron_aq::Definition())),
                     picosecond,
                     pFinalPosition ? *pFinalPosition : pIncomingTrack->GetPosition(),
                     pIncomingTrack->GetTrackID());
    }
}

Referenced by G4TDNAOneStepThermalizationModel< MODEL >::SampleSecondaries(), and G4DNATransformElectronModel::SampleSecondaries().

◆ CreateWaterMolecule()

void G4DNAChemistryManager::CreateWaterMolecule	(	ElectronicModification	modification,
		G4int	electronicLevel,
		const G4Track *	pIncomingTrack
	)

Method used by DNA physics model to create a water molecule. The ElectronicModification is a flag telling whether the molecule is ionized or excited, the electronic level is calculated by the model and the IncomingTrack is the track responsible for the creation of this molecule (electron, proton...).

Definition at line 606 of file G4DNAChemistryManager.cc.

{
    if (fpThreadData->fpPhysChemIO)
    {
        G4double energy = -1.;
 
        switch (modification)
        {
        case eDissociativeAttachment:
            energy = 0.;
            break;
        case eExcitedMolecule:
            energy = GetExcitationLevel()->ExcitationEnergy(electronicLevel);
            break;
        case eIonizedMolecule:
            energy = GetIonisationLevel()->IonisationEnergy(electronicLevel);
            break;
        }
 
        fpThreadData->fpPhysChemIO->CreateWaterMolecule(modification,
                                                        4 - electronicLevel,
                                                        energy,
                                                        pIncomingTrack);
    }
 
    if (fActiveChemistry)
    {
        G4Molecule* pH2OMolecule = new G4Molecule(G4H2O::Definition());
 
        switch (modification)
        {
        case eDissociativeAttachment:
            pH2OMolecule->AddElectron(5, 1);
            break;
        case eExcitedMolecule:
            pH2OMolecule->ExciteMolecule(4 - electronicLevel);
            break;
        case eIonizedMolecule:
            pH2OMolecule->IonizeMolecule(4 - electronicLevel);
            break;
        }
 
        G4Track* pH2OTrack = pH2OMolecule->BuildTrack(picosecond,
                                                      pIncomingTrack->GetPosition());
 
        pH2OTrack->SetParentID(pIncomingTrack->GetTrackID());
        pH2OTrack->SetTrackStatus(fStopButAlive);
        pH2OTrack->SetKineticEnergy(0.);
        PushTrack(pH2OTrack);
    }
}

◆ DeleteInstance()

void G4DNAChemistryManager::DeleteInstance ( )

static

Definition at line 202 of file G4DNAChemistryManager.cc.

{
    G4AutoLock lock(&chemManExistence);
 
    if (fgInstance != nullptr)
    {
        G4DNAChemistryManager* pDeleteMe = fgInstance;
        fgInstance = nullptr;
        lock.unlock();
        delete pDeleteMe;
    }
    else
    {
        G4cerr << "G4DNAChemistryManager already deleted" << G4endl;
    }
    lock.unlock();
}

◆ Deregister()

void G4DNAChemistryManager::Deregister ( G4VUserChemistryList & chemistryList )

Definition at line 730 of file G4DNAChemistryManager.cc.

{
    if (fpUserChemistryList.get() == &chemistryList)
    {
        if (!fpUserChemistryList->IsPhysicsConstructor() || fOwnChemistryList)
        {
            fpUserChemistryList.reset();
        }
 
        fpUserChemistryList.release();
    }
}

Referenced by Clear(), and G4VUserChemistryList::~G4VUserChemistryList().

◆ ForceMasterReinitialization()

void G4DNAChemistryManager::ForceMasterReinitialization ( )

Definition at line 780 of file G4DNAChemistryManager.cc.

{
    fMasterInitialized = false;
    InitializeMaster();
}

◆ ForceRebuildingPhysicsTable()

void G4DNAChemistryManager::ForceRebuildingPhysicsTable ( )

Definition at line 773 of file G4DNAChemistryManager.cc.

{
    fPhysicsTableBuilt = false;
}

◆ ForceThreadReinitialization()

void G4DNAChemistryManager::ForceThreadReinitialization ( )

Definition at line 788 of file G4DNAChemistryManager.cc.

{
    fForceThreadReinitialization = true;
}

◆ GetCurrentValue()

G4String G4DNAChemistryManager::GetCurrentValue ( G4UIcommand * pCommand )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 278 of file G4DNAChemistryManager.cc.

{
    if (pCommand == fpActivateChem.get())
    {
        return G4UIcmdWithABool::ConvertToString(fActiveChemistry);
    }
    else if (pCommand == fpScaleForNewTemperature.get())
    {
        return fpScaleForNewTemperature->ConvertToStringWithBestUnit(G4MolecularConfiguration::GetGlobalTemperature());
    }
    else if (pCommand == fpSkipReactionsFromChemList.get())
    {
        return G4UIcmdWithABool::ConvertToString(fSkipReactions);
    }
 
    return "";
}

◆ GetExcitationLevel()

G4DNAWaterExcitationStructure * G4DNAChemistryManager::GetExcitationLevel ( )

protected

Definition at line 584 of file G4DNAChemistryManager.cc.

{
    if (!fpExcitationLevel)
    {
        fpExcitationLevel.reset(new G4DNAWaterExcitationStructure);
    }
    return fpExcitationLevel.get();
}

Referenced by CreateWaterMolecule().

◆ GetInstanceIfExists()

G4DNAChemistryManager * G4DNAChemistryManager::GetInstanceIfExists ( )

static

Definition at line 157 of file G4DNAChemistryManager.cc.

{
    return fgInstance;
}

Referenced by G4VUserChemistryList::~G4VUserChemistryList().

◆ GetIonisationLevel()

G4DNAWaterIonisationStructure * G4DNAChemistryManager::GetIonisationLevel ( )

protected

Definition at line 595 of file G4DNAChemistryManager.cc.

{
    if (!fpIonisationLevel)
    {
        fpIonisationLevel.reset(new G4DNAWaterIonisationStructure);
    }
    return fpIonisationLevel.get();
}

Referenced by CreateWaterMolecule().

◆ HandleStandaloneInitialization()

void G4DNAChemistryManager::HandleStandaloneInitialization ( )

protected

Definition at line 438 of file G4DNAChemistryManager.cc.

{
    if (!fUseInStandalone || fPhysicsTableBuilt)
    {
        return;
    }
 
    if (fVerbose)
    {
        G4cout << "G4DNAChemistryManager: Build the physics tables for "
                  "molecule definition only."
               << G4endl;
    }
 
    fpUserChemistryList->BuildPhysicsTable();
 
    if (!fGeometryClosed)
    {
        if (fVerbose)
        {
            G4cout << "G4DNAChemistryManager: Close geometry" << G4endl;
        }
 
        G4GeometryManager* pGeomManager = G4GeometryManager::GetInstance();
        pGeomManager->OpenGeometry();
        pGeomManager->CloseGeometry(true, true);
        fGeometryClosed = true;
    }
 
    fPhysicsTableBuilt = true;
}

Referenced by InitializeThread().

◆ Initialize()

void G4DNAChemistryManager::Initialize ( )

Definition at line 360 of file G4DNAChemistryManager.cc.

{
    //===========================================================================
    // MT MODE
    //===========================================================================
    if (G4Threading::IsMultithreadedApplication())
    {
        //==========================================================================
        // ON WORKER THREAD
        //==========================================================================
        if (G4Threading::IsWorkerThread())
        {
            InitializeThread(); // Will create and initialize G4Scheduler
            return;
        }
        //==========================================================================
        // ON MASTER THREAD
        //==========================================================================
        else
        {
            InitializeMaster();
            InitializeThreadSharedData();
            return;
        }
    }
    //===========================================================================
    // IS NOT IN MT MODE
    //===========================================================================
    else
    {
        InitializeMaster();
        InitializeThreadSharedData();
        // In this case: InitializeThread is called when Run() is called
        return;
    }
}

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

◆ InitializeFile()

void G4DNAChemistryManager::InitializeFile ( )

protected

Definition at line 507 of file G4DNAChemistryManager.cc.

{
    if (fVerbose)
    {
        G4cout << "G4DNAChemistryManager::InitializeFile() is called"
               << G4endl;
    }
 
    if (fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO->InitializeFile();
    }
}

Referenced by InitializeThread().

◆ InitializeMaster()

void G4DNAChemistryManager::InitializeMaster ( )

protected

Definition at line 399 of file G4DNAChemistryManager.cc.

{
    if (fMasterInitialized)
    {
        return;
    }
 
    if (fVerbose)
    {
        G4cout << "G4DNAChemistryManager::InitializeMaster() is called" << G4endl;
    }
 
 
    if (fpUserChemistryList == nullptr)
    {
        G4ExceptionDescription description;
        description << "No user chemistry list has been provided.";
        G4Exception("G4DNAChemistryManager::InitializeMaster", "NO_CHEM_LIST",
                    FatalException, description);
    }
 
    G4Scheduler::Instance();
    // creates a concrete object of the scheduler
 
 
    fpUserChemistryList->ConstructDissociationChannels();
    if (!fSkipReactions)
    {
        fpUserChemistryList->ConstructReactionTable(G4DNAMolecularReactionTable::GetReactionTable());
    }
    else
    {
        G4DNAMolecularReactionTable::GetReactionTable(); // init pointer
    }
    fMasterInitialized = true;
}

Referenced by ForceMasterReinitialization(), and Initialize().

◆ InitializeThread()

void G4DNAChemistryManager::InitializeThread ( )

protected

Definition at line 472 of file G4DNAChemistryManager.cc.

{
    if (fpThreadData->fThreadInitialized && !fForceThreadReinitialization)
    {
        return;
    }
 
    if (fpUserChemistryList == nullptr)
    {
        G4ExceptionDescription description;
        description << "No user chemistry list has been provided.";
        G4Exception("G4DNAChemistryManager::InitializeThread", "NO_CHEM_LIST",
                    FatalException, description);
    }
 
    if (fVerbose)
    {
        G4cout << "G4DNAChemistryManager::InitializeThread() is called"
               << G4endl;
    }
 
    HandleStandaloneInitialization();
 
    fpUserChemistryList->ConstructTimeStepModel(G4DNAMolecularReactionTable::GetReactionTable());
    G4Scheduler::Instance()->Initialize();
 
    fpThreadData->fThreadInitialized = true;
 
    G4VMoleculeCounter::InitializeInstance();
 
    InitializeFile();
}

Referenced by Initialize(), Run(), and SetNewValue().

◆ InitializeThreadSharedData()

void G4DNAChemistryManager::InitializeThreadSharedData ( )

protected

Definition at line 298 of file G4DNAChemistryManager.cc.

{
    if (!G4Threading::IsMasterThread())
    {
        return;
    }
 
    G4MoleculeTable::Instance()->PrepareMolecularConfiguration();
    G4MoleculeTable::Instance()->Finalize();
}

Referenced by Initialize(), and Notify().

◆ Instance()

G4DNAChemistryManager * G4DNAChemistryManager::Instance ( )

static

Definition at line 132 of file G4DNAChemistryManager.cc.

{
    if (fgInstance == nullptr)
    {
        G4AutoLock lock(&chemManExistence);
        if (fgInstance == nullptr) // MT : double check at initialisation
        {
            fgInstance = new G4DNAChemistryManager();
        }
        lock.unlock();
    }
 
    // make sure thread local data is initialized for all threads
    if (fpThreadData == nullptr)
    {
        fpThreadData = new ThreadLocalData();
    }
 
    assert(fpThreadData != nullptr);
 
    return fgInstance;
}

◆ IsActivated()

G4bool G4DNAChemistryManager::IsActivated ( )

static

Definition at line 523 of file G4DNAChemistryManager.cc.

{
    return fgInstance ? fgInstance->IsChemistryActivated() : false;
}

Referenced by G4TDNAOneStepThermalizationModel< MODEL >::SampleSecondaries().

◆ IsChemistryActivated()

G4bool G4DNAChemistryManager::IsChemistryActivated ( )

Definition at line 530 of file G4DNAChemistryManager.cc.

{
    return fActiveChemistry;
}

Referenced by IsActivated().

◆ IsCounterResetWhenRunEnds()

G4bool G4DNAChemistryManager::IsCounterResetWhenRunEnds ( ) const

Definition at line 759 of file G4DNAChemistryManager.cc.

{
    return fResetCounterWhenRunEnds;
}

◆ Notify()

G4bool G4DNAChemistryManager::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 222 of file G4DNAChemistryManager.cc.

{
    if (requestedState == G4State_Quit)
    {
        if (fVerbose)
        {
            G4cout << "G4DNAChemistryManager::Notify ---> received G4State_Quit"
                   << G4endl;
        }
        Clear();
    }
    else if (requestedState == G4State_GeomClosed)
    {
        fGeometryClosed = true;
    }
    else if (requestedState == G4State_Idle)
    {
        InitializeThreadSharedData();
    }
 
    return true;
}

◆ PushMolecule()

void G4DNAChemistryManager::PushMolecule	(	std::unique_ptr< G4Molecule >	pMolecule,
		G4double	time,
		const G4ThreeVector &	position,
		G4int	parentID
	)

Definition at line 682 of file G4DNAChemistryManager.cc.

{
    assert(fActiveChemistry
           && "To inject chemical species, the chemistry must be activated. "
              "Check chemistry activation before injecting species.");
    G4Track* pTrack = pMolecule->BuildTrack(time, position);
    pTrack->SetTrackStatus(fAlive);
    pTrack->SetParentID(parentID);
    pMolecule.release();
    PushTrack(pTrack);
}

Referenced by CreateSolvatedElectron().

◆ PushTrack()

void G4DNAChemistryManager::PushTrack ( G4Track * pTrack )

protected

Definition at line 745 of file G4DNAChemistryManager.cc.

{
    G4ITTrackHolder::Instance()->Push(pTrack);
}

Referenced by CreateWaterMolecule(), and PushMolecule().

◆ ResetCounterWhenRunEnds()

void G4DNAChemistryManager::ResetCounterWhenRunEnds ( G4bool resetCounterWhenRunEnds )

Definition at line 766 of file G4DNAChemistryManager.cc.

{
    fResetCounterWhenRunEnds = resetCounterWhenRunEnds;
}

◆ Run()

void G4DNAChemistryManager::Run ( )

Definition at line 310 of file G4DNAChemistryManager.cc.

{
    if (!fActiveChemistry)
    {
        return;
    }
 
    InitializeThread();
 
    if (!fMasterInitialized)
    {
        G4ExceptionDescription description;
        description << "Global components were not initialized.";
        G4Exception("G4DNAChemistryManager::Run", "MASTER_INIT", FatalException,
                    description);
    }
 
    if (!fpThreadData->fThreadInitialized)
    {
        G4ExceptionDescription description;
        description << "Thread local components were not initialized.";
        G4Exception("G4DNAChemistryManager::Run", "THREAD_INIT", FatalException,
                    description);
    }
    
    G4MoleculeTable::Instance()->Finalize();
    G4Scheduler::Instance()->Process();
    if (fResetCounterWhenRunEnds)
    {
        G4VMoleculeCounter::Instance()->ResetCounter();
    }
    CloseFile();
}

Referenced by SetNewValue().

◆ SetChemistryActivation()

void G4DNAChemistryManager::SetChemistryActivation ( G4bool flag )

Definition at line 537 of file G4DNAChemistryManager.cc.

{
    fActiveChemistry = flag;
}

Referenced by SetChemistryList(), and SetNewValue().

◆ SetChemistryList() [1/3]

void G4DNAChemistryManager::SetChemistryList ( G4VUserChemistryList & chemistryList )

Chemistry list is managed outside the chemistry manager (eg. constructor).

Definition at line 714 of file G4DNAChemistryManager.cc.

{
    fpUserChemistryList.reset(&chemistryList);
    fOwnChemistryList = false;
    SetChemistryActivation(true);
}

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

◆ SetChemistryList() [2/3]

void G4DNAChemistryManager::SetChemistryList ( G4VUserChemistryList * pChemistryList )

Definition at line 707 of file G4DNAChemistryManager.cc.

{
    fpUserChemistryList.reset(pChemistryList);
    fOwnChemistryList = false;
    SetChemistryActivation(true);
}

◆ SetChemistryList() [3/3]

void G4DNAChemistryManager::SetChemistryList ( std::unique_ptr< G4VUserChemistryList > pChemistryList )

Not a constructor or when used in standalone? Prefer this method.

Definition at line 721 of file G4DNAChemistryManager.cc.

{
    fpUserChemistryList = std::move(pChemistryList);
    fOwnChemistryList = true;
    SetChemistryActivation(true);
}

◆ SetGlobalTemperature()

void G4DNAChemistryManager::SetGlobalTemperature ( G4double temperatureKelvin )

protected

Definition at line 699 of file G4DNAChemistryManager.cc.

{
    G4MolecularConfiguration::SetGlobalTemperature(temp_K);
    G4DNAMolecularReactionTable::Instance()->ScaleReactionRateForNewTemperature(temp_K);
}

Referenced by SetNewValue().

◆ SetGun()

void G4DNAChemistryManager::SetGun ( G4ITGun * pChemSpeciesGun )

Inject custom species to the simulation.

This method should be called per thread, possibly from ActionInitialisation::Build. One can decide to set the same gun for all threads. It is the user responsibility to handle the pointer deletion.

Definition at line 353 of file G4DNAChemistryManager.cc.

{
    G4Scheduler::Instance()->SetGun(pChemGun);
}

◆ SetNewValue()

void G4DNAChemistryManager::SetNewValue	(	G4UIcommand *	pCommand,
		G4String	value
	)

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 247 of file G4DNAChemistryManager.cc.

{
    if (pCommand == fpActivateChem.get())
    {
        SetChemistryActivation(G4UIcmdWithABool::GetNewBoolValue(value));
    }
    else if (pCommand == fpRunChem.get())
    {
        int nbExec = value.empty() ? 1 : G4UIcommand::ConvertToInt(value);
        for (int i = 0 ; i < nbExec ; ++i)
        {
            Run();
        }
    }
    else if (pCommand == fpSkipReactionsFromChemList.get())
    {
        fSkipReactions = true;
    }
    else if (pCommand == fpScaleForNewTemperature.get())
    {
        SetGlobalTemperature(fpScaleForNewTemperature->ConvertToDimensionedDouble(value));
    }
    else if (pCommand == fpInitChem.get())
    {
        Initialize();
        InitializeThread();
    }
}

◆ SetPhysChemIO()

void G4DNAChemistryManager::SetPhysChemIO ( std::unique_ptr< G4VPhysChemIO > pPhysChemIO )

Definition at line 88 of file G4DNAChemistryManager.cc.

{
    fpThreadData->fpPhysChemIO = std::move(pPhysChemIO);
}

◆ SetVerbose()

void G4DNAChemistryManager::SetVerbose ( G4int verbose )

Definition at line 752 of file G4DNAChemistryManager.cc.

{
    fVerbose = verbose;
}

◆ TagThreadForReinitialization()

void G4DNAChemistryManager::TagThreadForReinitialization ( )

Definition at line 795 of file G4DNAChemistryManager.cc.

{
    fpThreadData->fThreadInitialized = false;
}

◆ UseAsStandalone()

void G4DNAChemistryManager::UseAsStandalone ( G4bool flag )

If the chemistry module is used in standalone (ie. without running the physics stage beforehand), the physics table still needs to be built. It is therefore necessary to flag the chemistry module as being run in standalone.

Definition at line 346 of file G4DNAChemistryManager.cc.

{
    fUseInStandalone = flag;
}

◆ WriteInto()

void G4DNAChemistryManager::WriteInto	(	const G4String &	output,
		std::ios_base::openmode	mode = `std::ios_base::out`
	)

Tells the chemMan to write into a file the position and electronic state of the water molecule and the position thermalized or not of the solvated electron

Definition at line 544 of file G4DNAChemistryManager.cc.

{
    if (fVerbose)
    {
        G4cout << "G4DNAChemistryManager: Write chemical stage into "
               << output.data() << G4endl;
    }
 
    if (!fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO.reset(new G4PhysChemIO::FormattedText());
    }
 
    fpThreadData->fpPhysChemIO->WriteInto(output, mode);
 
}

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~G4DNAChemistryManager()

◆ G4DNAChemistryManager()

Member Function Documentation

◆ AddEmptyLineInOutputFile()

◆ Clear()

◆ CloseFile()

◆ CreateSolvatedElectron()

◆ CreateWaterMolecule()

◆ DeleteInstance()

◆ Deregister()

◆ ForceMasterReinitialization()

◆ ForceRebuildingPhysicsTable()

◆ ForceThreadReinitialization()

◆ GetCurrentValue()

◆ GetExcitationLevel()

◆ GetInstanceIfExists()

◆ GetIonisationLevel()

◆ HandleStandaloneInitialization()

◆ Initialize()

◆ InitializeFile()

◆ InitializeMaster()

◆ InitializeThread()

◆ InitializeThreadSharedData()

◆ Instance()

◆ IsActivated()

◆ IsChemistryActivated()

◆ IsCounterResetWhenRunEnds()

◆ Notify()

◆ PushMolecule()

◆ PushTrack()

◆ ResetCounterWhenRunEnds()

◆ Run()

◆ SetChemistryActivation()

◆ SetChemistryList() [1/3]

◆ SetChemistryList() [2/3]

◆ SetChemistryList() [3/3]

◆ SetGlobalTemperature()

◆ SetGun()

◆ SetNewValue()

◆ SetPhysChemIO()

◆ SetVerbose()

◆ TagThreadForReinitialization()

◆ UseAsStandalone()

◆ WriteInto()