G4DNAChemistryManager Class Reference

#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)
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, const G4Track *parentTrack=nullptr)
void	BeginOfEventAction (const G4Event *)
void	BeginOfRunAction (const G4Run *)
void	EndOfEventAction (const G4Event *)
void	EndOfRunAction (const G4Run *)
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
virtual void	NotifyDeletion (const G4Event *)
virtual void	NotifyDeletion (const G4Run *)

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 (const 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 90 of file G4DNAChemistryManager.hh.

Constructor & Destructor Documentation

~G4DNAChemistryManager()

G4DNAChemistryManager::~G4DNAChemistryManager ( )

overrideprotected

Definition at line 157 of file G4DNAChemistryManager.cc.

{
    Clear();
    fgInstance = nullptr;
}

G4DNAChemistryManager()

G4DNAChemistryManager::G4DNAChemistryManager ( )

protected

Definition at line 104 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 DeleteInstance(), GetInstanceIfExists(), and Instance().

Member Function Documentation

AddEmptyLineInOutputFile()

void G4DNAChemistryManager::AddEmptyLineInOutputFile

(

)

Definition at line 558 of file G4DNAChemistryManager.cc.

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

BeginOfEventAction()

void G4DNAChemistryManager::BeginOfEventAction

(

const G4Event *

pEvent

)

Definition at line 778 of file G4DNAChemistryManager.cc.

{
    G4MoleculeCounterManager::Instance()->BeginOfEventAction(pEvent);
}

BeginOfRunAction()

void G4DNAChemistryManager::BeginOfRunAction

(

const G4Run *

pRun

)

Definition at line 785 of file G4DNAChemistryManager.cc.

{
    G4MoleculeCounterManager::Instance()->BeginOfRunAction(pRun);
}

Clear()

void G4DNAChemistryManager::Clear

(

)

Definition at line 165 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();
    if (G4MoleculeCounterManager::GetInstanceIfExists() != nullptr)
      G4MoleculeCounterManager::DeleteInstance();
}

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

CloseFile()

void G4DNAChemistryManager::CloseFile

(

)

Close the file specified with WriteInto

Definition at line 568 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 668 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 ? *pFinalPosition : pIncomingTrack->GetPosition(),
                     pIncomingTrack->GetTrackID(),
                     pIncomingTrack);
    }
}

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 600 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(),
                                                      pIncomingTrack);
 
        pH2OTrack->SetParentID(pIncomingTrack->GetTrackID());
        pH2OTrack->SetTrackStatus(fStopButAlive);
        pH2OTrack->SetKineticEnergy(0.);
        PushTrack(pH2OTrack);
    }
}

Referenced by G4DNABornExcitationModel1::SampleSecondaries(), G4DNABornExcitationModel2::SampleSecondaries(), G4DNABornIonisationModel2::SampleSecondaries(), G4DNACPA100ExcitationModel::SampleSecondaries(), G4DNACPA100IonisationModel::SampleSecondaries(), G4DNADingfelderChargeDecreaseModel::SampleSecondaries(), G4DNAEmfietzoglouExcitationModel::SampleSecondaries(), G4DNAEmfietzoglouIonisationModel::SampleSecondaries(), G4DNAMillerGreenExcitationModel::SampleSecondaries(), G4DNAPTBExcitationModel::SampleSecondaries(), G4DNARPWBAExcitationModel::SampleSecondaries(), G4DNARPWBAIonisationModel::SampleSecondaries(), G4DNARuddIonisationExtendedModel::SampleSecondaries(), and G4DNARuddIonisationModel::SampleSecondaries().

DeleteInstance()

void G4DNAChemistryManager::DeleteInstance ( )

static

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

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

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

EndOfEventAction()

void G4DNAChemistryManager::EndOfEventAction

(

const G4Event *

pEvent

)

Definition at line 792 of file G4DNAChemistryManager.cc.

{
    G4MoleculeCounterManager::Instance()->EndOfEventAction(pEvent);
}

EndOfRunAction()

void G4DNAChemistryManager::EndOfRunAction

(

const G4Run *

pRun

)

Definition at line 799 of file G4DNAChemistryManager.cc.

{
    G4MoleculeCounterManager::Instance()->EndOfRunAction(pRun);
}

ForceMasterReinitialization()

void G4DNAChemistryManager::ForceMasterReinitialization

(

)

Definition at line 813 of file G4DNAChemistryManager.cc.

{
    fMasterInitialized = false;
    InitializeMaster();
}

ForceRebuildingPhysicsTable()

void G4DNAChemistryManager::ForceRebuildingPhysicsTable

(

)

Definition at line 806 of file G4DNAChemistryManager.cc.

{
    fPhysicsTableBuilt = false;
}

ForceThreadReinitialization()

void G4DNAChemistryManager::ForceThreadReinitialization

(

)

Definition at line 821 of file G4DNAChemistryManager.cc.

{
    fForceThreadReinitialization = true;
}

GetCurrentValue()

G4String G4DNAChemistryManager::GetCurrentValue ( G4UIcommand * pCommand )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 272 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 578 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 150 of file G4DNAChemistryManager.cc.

{
    return fgInstance;
}

Referenced by G4VUserChemistryList::~G4VUserChemistryList().

GetIonisationLevel()

G4DNAWaterIonisationStructure * G4DNAChemistryManager::GetIonisationLevel ( )

protected

Definition at line 589 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 430 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 501 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
 
    if (G4MoleculeCounterManager::GetInstanceIfExists() != nullptr)
        G4MoleculeCounterManager::Instance()->Initialize();
 
    fMasterInitialized = true;
}

Referenced by ForceMasterReinitialization(), and Initialize().

InitializeThread()

void G4DNAChemistryManager::InitializeThread ( )

protected

Definition at line 464 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();
 
    if (G4MoleculeCounterManager::GetInstanceIfExists() != nullptr)
      G4MoleculeCounterManager::Instance()->Initialize();
 
    fpThreadData->fThreadInitialized = true;
 
    InitializeFile();
}

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

InitializeThreadSharedData()

void G4DNAChemistryManager::InitializeThreadSharedData ( )

protected

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

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry::G4EmDNAChemistry(), G4EmDNAChemistry_option1::G4EmDNAChemistry_option1(), G4EmDNAChemistry_option2::G4EmDNAChemistry_option2(), G4EmDNAChemistry_option3::G4EmDNAChemistry_option3(), G4DNABornIonisationModel1::Initialise(), G4DNABornIonisationModel::Initialise(), G4DNARuddIonisationDynamicModel::Initialise(), G4DNABornExcitationModel1::SampleSecondaries(), G4DNABornExcitationModel2::SampleSecondaries(), G4DNABornIonisationModel2::SampleSecondaries(), G4DNACPA100ExcitationModel::SampleSecondaries(), G4DNACPA100IonisationModel::SampleSecondaries(), G4DNADingfelderChargeDecreaseModel::SampleSecondaries(), G4DNAEmfietzoglouExcitationModel::SampleSecondaries(), G4DNAEmfietzoglouIonisationModel::SampleSecondaries(), G4DNAMeltonAttachmentModel::SampleSecondaries(), G4DNAMillerGreenExcitationModel::SampleSecondaries(), G4DNAPTBExcitationModel::SampleSecondaries(), G4DNARPWBAExcitationModel::SampleSecondaries(), G4DNARPWBAIonisationModel::SampleSecondaries(), G4DNARuddIonisationExtendedModel::SampleSecondaries(), G4DNARuddIonisationModel::SampleSecondaries(), G4DNATransformElectronModel::SampleSecondaries(), and G4TDNAOneStepThermalizationModel< MODEL >::SampleSecondaries().

IsActivated()

G4bool G4DNAChemistryManager::IsActivated ( )

static

Definition at line 517 of file G4DNAChemistryManager.cc.

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

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

IsChemistryActivated()

G4bool G4DNAChemistryManager::IsChemistryActivated

(

)

Definition at line 524 of file G4DNAChemistryManager.cc.

{
    return fActiveChemistry;
}

Notify()

G4bool G4DNAChemistryManager::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 216 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,
		const G4Track *	parentTrack = nullptr )

Definition at line 700 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, parentTrack);
    pTrack->SetTrackStatus(fAlive);
    pTrack->SetParentID(parentID);
    pMolecule.release();
    PushTrack(pTrack);
}

Referenced by CreateSolvatedElectron().

PushTrack()

void G4DNAChemistryManager::PushTrack ( G4Track * pTrack )

protected

Definition at line 764 of file G4DNAChemistryManager.cc.

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

Referenced by CreateWaterMolecule(), and PushMolecule().

Run()

void G4DNAChemistryManager::Run

(

)

Definition at line 304 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();
 
    CloseFile();
}

Referenced by SetNewValue().

SetChemistryActivation()

void G4DNAChemistryManager::SetChemistryActivation

(

G4bool

flag

)

Definition at line 531 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 733 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 726 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 740 of file G4DNAChemistryManager.cc.

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

SetGlobalTemperature()

void G4DNAChemistryManager::SetGlobalTemperature ( G4double temperatureKelvin )

protected

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

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

SetVerbose()

void G4DNAChemistryManager::SetVerbose

(

G4int

verbose

)

Definition at line 771 of file G4DNAChemistryManager.cc.

{
    fVerbose = verbose;
}

TagThreadForReinitialization()

void G4DNAChemistryManager::TagThreadForReinitialization

(

)

Definition at line 828 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 538 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:

• G4DNAChemistryManager.hh
• G4DNAChemistryManager.cc