#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 ()=default

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

virtual	~G4UImessenger ()

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

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	LtoS (G4long l)

G4String	DtoS (G4double a)

G4String	BtoS (G4bool b)

G4int	StoI (const G4String &s)

G4long	StoL (const G4String &s)

G4double	StoD (const 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 156 of file G4DNAChemistryManager.cc.

{
    Clear();
    fgInstance = nullptr;
}

◆ G4DNAChemistryManager()

G4DNAChemistryManager::G4DNAChemistryManager ( )

protected

Definition at line 103 of file G4DNAChemistryManager.cc.

        : 
         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))
        , 
         fpExcitationLevel(nullptr)
        , fpIonisationLevel(nullptr)
        , fpUserChemistryList(nullptr)
{
    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 553 of file G4DNAChemistryManager.cc.

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

◆ Clear()

void G4DNAChemistryManager::Clear ( )

Definition at line 164 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 563 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)
    {
        G4double delayedTime = 0.;
        if(pIncomingTrack->GetUserInformation() != nullptr)
        {
            auto pPulseInfo = dynamic_cast<G4VUserPulseInfo*>
              (pIncomingTrack->GetUserInformation());
            if(pPulseInfo != nullptr)
            {
                delayedTime = pPulseInfo->GetDelayedTime();
            }
        }
 
        PushMolecule(std::make_unique<G4Molecule>(G4Electron_aq::Definition()),
                     picosecond + delayedTime,
                     pFinalPosition != nullptr ? *pFinalPosition : pIncomingTrack->GetPosition(),
                     pIncomingTrack->GetTrackID());
    }
}

Referenced by G4DNATransformElectronModel::SampleSecondaries(), and G4TDNAOneStepThermalizationModel< MODEL >::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 595 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)
    {
        auto  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;
        }
 
        G4double delayedTime = 0.;
        if(pIncomingTrack->GetUserInformation() != nullptr)
        {
            auto pPulseInfo = dynamic_cast<G4VUserPulseInfo*>
              (pIncomingTrack->GetUserInformation());
            if(pPulseInfo != nullptr)
            {
                delayedTime = pPulseInfo->GetDelayedTime();
            }
        }
 
        G4Track* pH2OTrack = pH2OMolecule->BuildTrack(picosecond + delayedTime,
                                                      pIncomingTrack->GetPosition());
 
        pH2OTrack->SetParentID(pIncomingTrack->GetTrackID());
        pH2OTrack->SetTrackStatus(fStopButAlive);
        pH2OTrack->SetKineticEnergy(0.);
        PushTrack(pH2OTrack);
    }
}

◆ DeleteInstance()

void G4DNAChemistryManager::DeleteInstance ( )

static

Definition at line 194 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 741 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 791 of file G4DNAChemistryManager.cc.

{
    fMasterInitialized = false;
    InitializeMaster();
}

◆ ForceRebuildingPhysicsTable()

void G4DNAChemistryManager::ForceRebuildingPhysicsTable ( )

Definition at line 784 of file G4DNAChemistryManager.cc.

{
    fPhysicsTableBuilt = false;
}

◆ ForceThreadReinitialization()

void G4DNAChemistryManager::ForceThreadReinitialization ( )

Definition at line 799 of file G4DNAChemistryManager.cc.

{
    fForceThreadReinitialization = true;
}

◆ GetCurrentValue()

G4String G4DNAChemistryManager::GetCurrentValue ( G4UIcommand * pCommand )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 270 of file G4DNAChemistryManager.cc.

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

◆ GetExcitationLevel()

G4DNAWaterExcitationStructure * G4DNAChemistryManager::GetExcitationLevel ( )

protected

Definition at line 573 of file G4DNAChemistryManager.cc.

{
    if (!fpExcitationLevel)
    {
        fpExcitationLevel = std::make_unique<G4DNAWaterExcitationStructure>();
    }
    return fpExcitationLevel.get();
}

Referenced by CreateWaterMolecule().

◆ GetInstanceIfExists()

G4DNAChemistryManager * G4DNAChemistryManager::GetInstanceIfExists ( )

static

Definition at line 149 of file G4DNAChemistryManager.cc.

{
    return fgInstance;
}

Referenced by G4VUserChemistryList::~G4VUserChemistryList().

◆ GetIonisationLevel()

G4DNAWaterIonisationStructure * G4DNAChemistryManager::GetIonisationLevel ( )

protected

Definition at line 584 of file G4DNAChemistryManager.cc.

{
    if (!fpIonisationLevel)
    {
        fpIonisationLevel = std::make_unique<G4DNAWaterIonisationStructure>();
    }
    return fpIonisationLevel.get();
}

Referenced by CreateWaterMolecule().

◆ HandleStandaloneInitialization()

void G4DNAChemistryManager::HandleStandaloneInitialization ( )

protected

Definition at line 426 of file G4DNAChemistryManager.cc.

{
    if (!fUseInStandalone || fPhysicsTableBuilt)
    {
        return;
    }
 
    if (fVerbose != 0)
    {
        G4cout << "G4DNAChemistryManager: Build the physics tables for "
                  "molecule definition only."
               << G4endl;
    }
 
    fpUserChemistryList->BuildPhysicsTable();
 
    if (!fGeometryClosed)
    {
        if (fVerbose != 0)
        {
            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 352 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
        //==========================================================================
        
        InitializeMaster();
        InitializeThreadSharedData();
        return;
    }
    //===========================================================================
    // IS NOT IN MT MODE
    //===========================================================================
    
    InitializeMaster();
    InitializeThreadSharedData();
    // In this case: InitializeThread is called when Run() is called
    return;
}

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

◆ InitializeFile()

void G4DNAChemistryManager::InitializeFile ( )

protected

Definition at line 496 of file G4DNAChemistryManager.cc.

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

Referenced by InitializeThread().

◆ InitializeMaster()

void G4DNAChemistryManager::InitializeMaster ( )

protected

Definition at line 387 of file G4DNAChemistryManager.cc.

{
    if (fMasterInitialized)
    {
        return;
    }
 
    if (fVerbose != 0)
    {
        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);
    }else
    {
      fpUserChemistryList->ConstructDissociationChannels();
      if (!fSkipReactions)
      {
          fpUserChemistryList->ConstructReactionTable(G4DNAMolecularReactionTable::GetReactionTable());
      }
      else
      {
          G4DNAMolecularReactionTable::GetReactionTable(); // init pointer
      }
    }
 
    G4Scheduler::Instance();
    // creates a concrete object of the scheduler
    fMasterInitialized = true;
}

Referenced by ForceMasterReinitialization(), and Initialize().

◆ InitializeThread()

void G4DNAChemistryManager::InitializeThread ( )

protected

Definition at line 460 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);
    }else
    {
        HandleStandaloneInitialization();// To make coverty happy
        fpUserChemistryList->ConstructTimeStepModel(G4DNAMolecularReactionTable::GetReactionTable());
    }
 
    if (fVerbose != 0)
    {
        G4cout << "G4DNAChemistryManager::InitializeThread() is called"
               << G4endl;
    }
 
    G4Scheduler::Instance()->Initialize();
 
    fpThreadData->fThreadInitialized = true;
 
    G4VMoleculeCounter::InitializeInstance();
 
    InitializeFile();
}

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

◆ InitializeThreadSharedData()

void G4DNAChemistryManager::InitializeThreadSharedData ( )

protected

Definition at line 290 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 124 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 512 of file G4DNAChemistryManager.cc.

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

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

◆ IsChemistryActivated()

G4bool G4DNAChemistryManager::IsChemistryActivated ( )

Definition at line 519 of file G4DNAChemistryManager.cc.

{
    return fActiveChemistry;
}

Referenced by IsActivated().

◆ IsCounterResetWhenRunEnds()

G4bool G4DNAChemistryManager::IsCounterResetWhenRunEnds ( ) const

Definition at line 770 of file G4DNAChemistryManager.cc.

{
    return fResetCounterWhenRunEnds;
}

◆ Notify()

G4bool G4DNAChemistryManager::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 214 of file G4DNAChemistryManager.cc.

{
    if (requestedState == G4State_Quit)
    {
        if (fVerbose != 0)
        {
            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 693 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 756 of file G4DNAChemistryManager.cc.

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

Referenced by CreateWaterMolecule(), and PushMolecule().

◆ ResetCounterWhenRunEnds()

void G4DNAChemistryManager::ResetCounterWhenRunEnds ( G4bool resetCounterWhenRunEnds )

Definition at line 777 of file G4DNAChemistryManager.cc.

{
    fResetCounterWhenRunEnds = resetCounterWhenRunEnds;
}

◆ Run()

void G4DNAChemistryManager::Run ( )

Definition at line 302 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 526 of file G4DNAChemistryManager.cc.

{
    fActiveChemistry = flag;
}

Referenced by SetChemistryList(), SetChemistryList(), SetChemistryList(), and SetNewValue().

◆ SetChemistryList() [1/3]

void G4DNAChemistryManager::SetChemistryList ( G4VUserChemistryList & chemistryList )

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

Definition at line 725 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 718 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 732 of file G4DNAChemistryManager.cc.

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

◆ SetGlobalTemperature()

void G4DNAChemistryManager::SetGlobalTemperature ( G4double temperatureKelvin )

protected

Definition at line 710 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 345 of file G4DNAChemistryManager.cc.

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

◆ SetNewValue()

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

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 239 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 90 of file G4DNAChemistryManager.cc.

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

◆ SetVerbose()

void G4DNAChemistryManager::SetVerbose ( G4int verbose )

Definition at line 763 of file G4DNAChemistryManager.cc.

{
    fVerbose = verbose;
}

◆ TagThreadForReinitialization()

void G4DNAChemistryManager::TagThreadForReinitialization ( )

Definition at line 806 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 338 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 533 of file G4DNAChemistryManager.cc.

{
    if (fVerbose != 0)
    {
        G4cout << "G4DNAChemistryManager: Write chemical stage into "
               << output.data() << G4endl;
    }
 
    if (!fpThreadData->fpPhysChemIO)
    {
        fpThreadData->fpPhysChemIO = std::make_unique<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()