G4DNAChemistryManager Class Reference

#include <G4DNAChemistryManager.hh>

Inheritance diagram for G4DNAChemistryManager:

Collaboration diagram for G4DNAChemistryManager:

Public Member Functions
G4bool	IsChemistryActivated ()
void	SetChemistryActivation (G4bool)
virtual G4bool	Notify (G4ApplicationState requestedState)
virtual void	SetNewValue (G4UIcommand *, G4String)
virtual G4String	GetCurrentValue (G4UIcommand *command)
void	Initialize ()
void	SetChemistryList (G4VUserChemistryList *)
void	Deregister (G4VUserChemistryList *)
void	SetGlobalTemperature (double temp_K)
void	ForceMasterReinitialization ()
void	TagThreadForReinitialization ()
void	Run ()
void	Clear ()
void	Gun (G4ITGun *, bool physicsTableToBuild=true)
void	ForceThreadReinitialization ()
void	ForceRebuildingPhysicsTable ()
void	WriteInto (const G4String &, std::ios_base::openmode mode=std::ios_base::out)
void	AddEmptyLineInOuputFile ()
void	CloseFile ()
void	CreateWaterMolecule (ElectronicModification, G4int, const G4Track *)
void	CreateSolvatedElectron (const G4Track *, G4ThreeVector *finalPosition=0)
void	PushMolecule (G4Molecule *&molecule, double time, const G4ThreeVector &position, int parentID)
void	PushMoleculeAtParentTimeAndPlace (G4Molecule *&molecule, const G4Track *)
void	SetVerbose (G4int verbose)
void	SetBuildPhysicsTable (bool flag)
G4bool	IsCounterResetWhenRunEnds () const
void	ResetCounterWhenRunEnds (G4bool resetCounterWhenRunEnds)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const
Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)
virtual	~G4VStateDependent ()
G4int	operator== (const G4VStateDependent &right) const
G4int	operator!= (const G4VStateDependent &right) const

Static Public Member Functions
static G4DNAChemistryManager *	Instance ()
static G4DNAChemistryManager *	GetInstanceIfExists ()
static void	DeleteInstance ()
static G4bool	IsActivated ()
static void	Activated (G4bool flag=true)

Protected Member Functions
virtual	~G4DNAChemistryManager ()
G4DNAWaterExcitationStructure *	GetExcitationLevel ()
G4DNAWaterIonisationStructure *	GetIonisationLevel ()
void	InitializeFile ()
void	InitializeMaster ()
void	InitializeThread ()
	G4DNAChemistryManager ()
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (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
G4String	baseDirName
G4bool	commandsShouldBeInMaster

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 88 of file G4DNAChemistryManager.hh.

Constructor & Destructor Documentation

G4DNAChemistryManager::~G4DNAChemistryManager ( )

protectedvirtual

Definition at line 137 of file G4DNAChemistryManager.cc.

{
//  G4cout << "Deleting G4DNAChemistryManager" << G4endl;
  Clear();
  fgInstance = 0;
  /*
   * DEBUG : check that the chemistry manager has well been deregistered
   *  assert(G4StateManager::GetStateManager()->
   *  DeregisterDependent(this) == true);
   */
}

Here is the call graph for this function:

G4DNAChemistryManager::G4DNAChemistryManager ( )

protected

Definition at line 70 of file G4DNAChemistryManager.cc.

                                             :
    G4UImessenger(), G4VStateDependent()
{
//==============================================================================
/* M.K: 24/11/2014
 * To work properly, the chemistry manager should be created and initialized on
 * the master thread only. If the static flag fActiveChemistry is on but the
 * chemistry manager singleton
 */
//==============================================================================

//  if (/*fActiveChemistry &&*/ G4Threading::IsWorkerThread()
//      && G4Threading::IsMultithreadedApplication())
//  {
//    G4Exception("G4DNAChemistryManager::G4DNAChemistryManager",
//                "G4DNAChemistryManager_MASTER_CREATION", FatalException,
//                "The chemistry manager should be created and initialized on the "
//                "master thread only");
//  }

  fpExcitationLevel = 0;
  fpIonisationLevel = 0;
  fWriteFile = false;
  fpUserChemistryList = 0;
  fMasterInitialized = false;
  fpChemDNADirectory = new G4UIdirectory("/chem/");
  fpActivateChem = new G4UIcmdWithABool("/chem/activate", this);
  fpRunChem = new G4UIcmdWithoutParameter("/chem/run", this);
  //fpGridSize = new G4UIcmdWithADoubleAndUnit("/chem/gridRes", this);
  fpScaleForNewTemperature = new G4UIcmdWithADoubleAndUnit("/chem/temperature",
                                                           this);
  fpSkipReactionsFromChemList =
      new G4UIcmdWithoutParameter("/chem/skipReactionsFromChemList", this);
  fpInitChem = new G4UIcmdWithoutParameter("/chem/init", this);
  //fDefaultGridResolution = -1;
  fBuildPhysicsTable = false;
  fGeometryClosed = false;
  fPhysicsTableBuilt = false;
  fForceThreadReinitialization = false;
  fFileInitialized = false;
  fVerbose = 0;
  fActiveChemistry = false;
  fSkipReactions = false;
  fResetCounterWhenRunEnds = true;
}

Here is the caller graph for this function:

Member Function Documentation

void G4DNAChemistryManager::Activated ( G4bool  flag = true )

static

Definition at line 500 of file G4DNAChemistryManager.cc.

{
  Instance()->fActiveChemistry = flag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::AddEmptyLineInOuputFile

(

)

Definition at line 530 of file G4DNAChemistryManager.cc.

{
  if (fWriteFile)
  {
    *fpgOutput_tl << G4endl;
  }
}

void G4DNAChemistryManager::Clear

(

)

Definition at line 149 of file G4DNAChemistryManager.cc.

{
  if (fpIonisationLevel)
  {
    delete fpIonisationLevel;
    fpIonisationLevel = 0;

  }
  if (fpExcitationLevel)
  {
    delete fpExcitationLevel;
    fpExcitationLevel = 0;
  }
  if (fpUserChemistryList)
  {
    if(fpUserChemistryList->IsPhysicsConstructor() == false)
    {
      delete fpUserChemistryList;
    }
//    else
//    {
//   G4cout << "G4DNAChemistryManager will not delete the chemistry list "
//       "since it inherits from G4VPhysicsConstructor and it is then "
//       "expected to be the responsability to the G4VModularPhysics to handle"
//       " the chemistry list." << G4endl;
//    }
    fpUserChemistryList = 0;
  }
  if (fpChemDNADirectory)
  {
    delete fpChemDNADirectory;
    fpChemDNADirectory = 0;
  }
  if (fpActivateChem)
  {
    delete fpActivateChem;
    fpActivateChem = 0;
  }
  if(fpRunChem)
  {
    delete fpRunChem;
    fpRunChem = 0;
  }
  if(fpSkipReactionsFromChemList)
  {
    delete fpSkipReactionsFromChemList;
    fpSkipReactionsFromChemList = 0;
  }
  if(fpInitChem)
  {
    delete fpInitChem;
    fpInitChem = 0;
  }

  G4DNAMolecularReactionTable::DeleteInstance();
  //G4MoleculeHandleManager::DeleteInstance();
  G4MolecularConfiguration::DeleteManager();
  G4VMoleculeCounter::DeleteInstance();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::CloseFile

(

)

Close the file specified with WriteInto

Definition at line 538 of file G4DNAChemistryManager.cc.

{
  if (fpgOutput_tl == 0) return;

  if (fpgOutput_tl->is_open())
  {
    if (fVerbose)
    {
      G4cout << "G4DNAChemistryManager: Close File" << G4endl;
    }
    fpgOutput_tl->close();
  }
}

Here is the caller graph for this function:

void G4DNAChemistryManager::CreateSolvatedElectron	(	const G4Track *	theIncomingTrack,
		G4ThreeVector *	finalPosition = 0
	)

On the same idea as the previous method but for solvated electron. This method should be used by the physics model of the ElectronSolvatation process.

Definition at line 638 of file G4DNAChemistryManager.cc.

{
  if (fWriteFile)
  {
    if(!fFileInitialized) InitializeFile();

    *fpgOutput_tl << setw(11) << theIncomingTrack->GetTrackID() << setw(10)
                  << "e_aq" << setw(14) << -1 << std::setprecision(2)
                  << std::fixed << setw(13)
                  << theIncomingTrack->GetKineticEnergy() / eV
                  << std::setprecision(6) << std::scientific << setw(22)
                  << (theIncomingTrack->GetPosition().x()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().y()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().z()) / nanometer;

    if (finalPosition != 0)
    {
      *fpgOutput_tl << setw(14) << (finalPosition->x()) / nanometer << setw(14)
                    << (finalPosition->y()) / nanometer << setw(14)
                    << (finalPosition->z()) / nanometer;
    }

    *fpgOutput_tl << G4endl;
  }

  if(fActiveChemistry)
  {
    G4Molecule* e_aq = new G4Molecule(G4Electron_aq::Definition());
    G4Track * e_aqTrack(0);
    if(finalPosition)
    {
      e_aqTrack = e_aq->BuildTrack(picosecond,*finalPosition);
    }
    else
    {
      e_aqTrack = e_aq->BuildTrack(picosecond,theIncomingTrack->GetPosition());
    }
    e_aqTrack -> SetTrackStatus(fAlive);
    e_aqTrack -> SetParentID(theIncomingTrack->GetTrackID());
    G4VITTrackHolder::Instance()->Push(e_aqTrack);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Method used by DNA physics model to create a water molecule. The ElectronicModification is a flag telling wheter 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, for instance an electron.

Definition at line 572 of file G4DNAChemistryManager.cc.

{
  if (fWriteFile)
  {
    if(!fFileInitialized) InitializeFile();

    G4double energy = -1.;

    switch (modification)
    {
      case eDissociativeAttachment:
        energy = 0;
        break;
      case eExcitedMolecule:
        energy = GetExcitationLevel()->ExcitationEnergy(electronicLevel);
        break;
      case eIonizedMolecule:
        energy = GetIonisationLevel()->IonisationEnergy(electronicLevel);
        break;
    }

    *fpgOutput_tl << setw(11) << left << theIncomingTrack->GetTrackID()
                  << setw(10) << "H2O" << left << modification << internal
                  << ":" << right << electronicLevel << left << setw(11) << ""
                  << std::setprecision(2) << std::fixed << setw(13)
                  << energy / eV << std::setprecision(6) << std::scientific
                  << setw(22)
                  << (theIncomingTrack->GetPosition().x()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().y()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().z()) / nanometer
                  << G4endl;
  }

  if(fActiveChemistry)
  {
    G4Molecule * H2O = new G4Molecule (G4H2O::Definition());

    switch (modification)
    {
      case eDissociativeAttachment:
      H2O -> AddElectron(5,1);
      break;
      case eExcitedMolecule :
      H2O -> ExciteMolecule(4-electronicLevel);
      break;
      case eIonizedMolecule :
      H2O -> IonizeMolecule(4-electronicLevel);
      break;
    }

    G4Track * H2OTrack = H2O->BuildTrack(1*picosecond,
        theIncomingTrack->GetPosition());

    H2OTrack -> SetParentID(theIncomingTrack->GetTrackID());
    H2OTrack -> SetTrackStatus(fStopButAlive);
    H2OTrack -> SetKineticEnergy(0.);
    G4VITTrackHolder::Instance()->Push(H2OTrack);
  }
//  else
//  abort();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::DeleteInstance ( )

static

You should rather use DeleteInstance than the destructor of this class

Definition at line 209 of file G4DNAChemistryManager.cc.

{
  //G4cout << "G4DNAChemistryManager::DeleteInstance" << G4endl;

  G4AutoLock lock(&chemManExistence);

  if(fgInstance)
  {
    G4DNAChemistryManager* deleteMe = fgInstance;
    fgInstance = 0;
    lock.unlock();
    delete deleteMe;
  }
  else
  {
    G4cout << "G4DNAChemistryManager already deleted" << G4endl;
  }
  lock.unlock();
}

Here is the call graph for this function:

void G4DNAChemistryManager::Deregister ( G4VUserChemistryList *  chemistryList )

inline

Definition at line 269 of file G4DNAChemistryManager.hh.

{
  if (fpUserChemistryList == chemistryList) fpUserChemistryList = 0;
}

Here is the caller graph for this function:

void G4DNAChemistryManager::ForceMasterReinitialization ( )

inline

Definition at line 274 of file G4DNAChemistryManager.hh.

{
  fMasterInitialized = false;
  InitializeMaster();
}

Here is the call graph for this function:

void G4DNAChemistryManager::ForceRebuildingPhysicsTable ( )

inline

Definition at line 258 of file G4DNAChemistryManager.hh.

{
  fPhysicsTableBuilt = false;
}

void G4DNAChemistryManager::ForceThreadReinitialization ( )

inline

Definition at line 280 of file G4DNAChemistryManager.hh.

{
  // TODO
  fForceThreadReinitialization = true;
}

G4String G4DNAChemistryManager::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 283 of file G4DNAChemistryManager.cc.

{
  if (command == fpActivateChem)
  {
    return G4UIcmdWithABool::ConvertToString(fActiveChemistry);
  }

  return "";
}

Here is the call graph for this function:

G4DNAWaterExcitationStructure * G4DNAChemistryManager::GetExcitationLevel ( )

protected

Definition at line 553 of file G4DNAChemistryManager.cc.

{
  if (!fpExcitationLevel)
  {
    fpExcitationLevel = new G4DNAWaterExcitationStructure;
  }
  return fpExcitationLevel;
}

Here is the caller graph for this function:

G4DNAChemistryManager * G4DNAChemistryManager::GetInstanceIfExists ( )

static

Definition at line 132 of file G4DNAChemistryManager.cc.

{
  return fgInstance;
}

Here is the caller graph for this function:

G4DNAWaterIonisationStructure * G4DNAChemistryManager::GetIonisationLevel ( )

protected

Definition at line 563 of file G4DNAChemistryManager.cc.

{
  if (!fpIonisationLevel)
  {
    fpIonisationLevel = new G4DNAWaterIonisationStructure;
  }
  return fpIonisationLevel;
}

Here is the caller graph for this function:

void G4DNAChemistryManager::Gun	(	G4ITGun *	gun,
		bool	physicsTableToBuild = true
	)

Definition at line 325 of file G4DNAChemistryManager.cc.

{
  fBuildPhysicsTable = physicsTableToBuild;
  G4Scheduler::Instance()->SetGun(gun);
}

Here is the call graph for this function:

void G4DNAChemistryManager::Initialize

(

)

Definition at line 331 of file G4DNAChemistryManager.cc.

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

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::InitializeFile ( )

protected

Definition at line 466 of file G4DNAChemistryManager.cc.

{
  if (fpgOutput_tl == 0 || fWriteFile == false || fFileInitialized)
  {
    return;
  }

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

  *fpgOutput_tl << std::setprecision(6) << std::scientific;
  *fpgOutput_tl << setw(11) << left << "#Parent ID" << setw(10) << "Molecule"
                << setw(14) << "Elec Modif" << setw(13) << "Energy (eV)"
                << setw(22) << "X pos of parent [nm]" << setw(22)
                << "Y pos of parent [nm]" << setw(22) << "Z pos of parent [nm]"
                << setw(14) << "X pos [nm]" << setw(14) << "Y pos [nm]"
                << setw(14) << "Z pos [nm]" << G4endl<< setw(21) << "#"
                << setw(13) << "1)io/ex=0/1"
                << G4endl
                << setw(21) << "#"
                << setw(13) << "2)level=0...5"
                << G4endl;

  fFileInitialized = true;
}

Here is the caller graph for this function:

void G4DNAChemistryManager::InitializeMaster ( )

protected

Definition at line 367 of file G4DNAChemistryManager.cc.

{
  if (fMasterInitialized == false)
  {
    if(fVerbose)
    {
     G4cout << "G4DNAChemistryManager::InitializeMaster() is called" << G4endl;
    }

    G4Scheduler::Instance(); 
    // creates a concrete object of the scheduler 
    // and track container

    if (fpUserChemistryList)
    {
      fpUserChemistryList->ConstructDissociationChannels();
      if(fSkipReactions == false)
      {
        fpUserChemistryList->ConstructReactionTable(
            G4DNAMolecularReactionTable::GetReactionTable());
      }
      else
      {
        G4DNAMolecularReactionTable::GetReactionTable(); // init pointer
      }
      fMasterInitialized = true;
    }
    else
    {
      if (fActiveChemistry)
      {
        G4ExceptionDescription description;
        description << "No user chemistry list has been provided.";
        G4Exception("G4DNAChemistryManager::InitializeMaster", "NO_CHEM_LIST",
                    FatalException, description);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::InitializeThread ( )

protected

Definition at line 407 of file G4DNAChemistryManager.cc.

{
  if (fpgThreadInitialized_tl == 0 || fForceThreadReinitialization == true)
  {
    if (fpUserChemistryList)
    {
      if(fVerbose)
      {
        G4cout << "G4DNAChemistryManager::InitializeThread() is called"
               << G4endl;
      }

      if (fBuildPhysicsTable && fPhysicsTableBuilt == false)
      {
        if(fVerbose)
        {
          G4cout << "G4DNAChemistryManager: Build the physics tables for "
              "molecules."
                 << G4endl;
        }

        fpUserChemistryList->BuildPhysicsTable();
        if (fGeometryClosed == false)
        {
          if(fVerbose)
          {
            G4cout << "G4DNAChemistryManager: Close geometry"
                   << G4endl;
          }

          G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
          // G4cout << "Start closing geometry." << G4endl;
          geomManager->OpenGeometry();
          geomManager->CloseGeometry(true, true);
          fGeometryClosed = true;
        }

        fPhysicsTableBuilt = true;
      }
      fpUserChemistryList->ConstructTimeStepModel(
          G4DNAMolecularReactionTable::GetReactionTable());
      G4Scheduler::Instance()->Initialize();

      fpgThreadInitialized_tl = new G4bool(true);
    }
    else
    {
      G4ExceptionDescription description;
      description << "No user chemistry list has been provided.";
      G4Exception("G4DNAChemistryManager::InitializeThread", "NO_CHEM_LIST",
                  FatalException, description);
    }

    G4VMoleculeCounter::InitializeInstance();
  }

  InitializeFile();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4DNAChemistryManager * G4DNAChemistryManager::Instance ( void  )

static

Definition at line 117 of file G4DNAChemistryManager.cc.

{
  if (fgInstance == 0)
  {
    G4AutoLock lock(&chemManExistence);
    if (fgInstance == 0) // MT : double check at initialisation
    {
      fgInstance = new G4DNAChemistryManager();
    }
    lock.unlock();
  }
  return fgInstance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4DNAChemistryManager::IsActivated ( )

static

Definition at line 495 of file G4DNAChemistryManager.cc.

{
  return Instance()->fActiveChemistry;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4DNAChemistryManager::IsChemistryActivated

(

)

Definition at line 505 of file G4DNAChemistryManager.cc.

{
  return fActiveChemistry;
}

G4bool G4DNAChemistryManager::IsCounterResetWhenRunEnds ( ) const

inline

Definition at line 206 of file G4DNAChemistryManager.hh.

  {
    return fResetCounterWhenRunEnds;
  }

G4bool G4DNAChemistryManager::Notify ( G4ApplicationState  requestedState )

virtual

Implements G4VStateDependent.

Definition at line 229 of file G4DNAChemistryManager.cc.

{
  if (requestedState == G4State_Quit)
  {
    if(fVerbose)
    G4cout << "G4DNAChemistryManager::Notify ---> received G4State_Quit"
           << G4endl;
    //DeleteInstance();
    Clear();
  }

  else if(requestedState == G4State_GeomClosed)
  {
    fGeometryClosed = true;
  }

  else if (requestedState == G4State_Idle)
  {
    G4MoleculeTable::Instance()->PrepareMolecularConfiguration();
  }

  return true;
}

Here is the call graph for this function:

void G4DNAChemistryManager::PushMolecule	(	G4Molecule *&	molecule,
		double	time,
		const G4ThreeVector &	position,
		int	parentID
	)

WARNING : In case chemistry is not activated, PushMolecule will take care of deleting the transfered molecule. Before calling this method, it is also possible to check if the chemistry is activated through IsChemistryActived(). This method will create the track corresponding to the transfered molecule and will be in charge of loading the new track to the system.

Definition at line 685 of file G4DNAChemistryManager.cc.

{
  if (fWriteFile)
  {
    if(!fFileInitialized) InitializeFile();

    *fpgOutput_tl << setw(11) << parentID << setw(10) << molecule->GetName()
                  << setw(14) << -1 << std::setprecision(2) << std::fixed
                  << setw(13) << -1 << std::setprecision(6) << std::scientific
                  << setw(22) << (position.x()) / nanometer << setw(22)
                  << (position.y()) / nanometer << setw(22)
                  << (position.z()) / nanometer;
    *fpgOutput_tl << G4endl;
  }

  if(fActiveChemistry)
  {
    G4Track* track = molecule->BuildTrack(time,position);
    track -> SetTrackStatus(fAlive);
    track -> SetParentID(parentID);
    G4VITTrackHolder::Instance()->Push(track);
  }
  else
  {
    delete molecule;
    molecule = 0;
  }
}

Here is the call graph for this function:

void G4DNAChemistryManager::PushMoleculeAtParentTimeAndPlace	(	G4Molecule *&	molecule,
		const G4Track *	theIncomingTrack
	)

WARNING : In case chemistry is not activated, PushMoleculeAtParentTimeAndPlace will take care of deleting the transfered molecule. Before calling this method, it is also possible to check if the chemistry is activated through IsChemistryActived(). This method will create the track corresponding to the transfered molecule and will be in charge of loading the new track to the system.

Definition at line 717 of file G4DNAChemistryManager.cc.

{
  if (fWriteFile)
  {
    if(!fFileInitialized) InitializeFile();

    *fpgOutput_tl << setw(11) << theIncomingTrack->GetTrackID() << setw(10)
                  << molecule->GetName() << setw(14) << -1
                  << std::setprecision(2) << std::fixed << setw(13)
                  << theIncomingTrack->GetKineticEnergy() / eV
                  << std::setprecision(6) << std::scientific << setw(22)
                  << (theIncomingTrack->GetPosition().x()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().y()) / nanometer
                  << setw(22)
                  << (theIncomingTrack->GetPosition().z()) / nanometer;
    *fpgOutput_tl << G4endl;
  }

  if(fActiveChemistry)
  {
    G4Track* track = molecule->BuildTrack(theIncomingTrack->GetGlobalTime(),
                                          theIncomingTrack->GetPosition());
    track -> SetTrackStatus(fAlive);
    track -> SetParentID(theIncomingTrack->GetTrackID());
    G4VITTrackHolder::Instance()->Push(track);
  }
  else
  {
    delete molecule;
    molecule = 0;
  }
}

Here is the call graph for this function:

void G4DNAChemistryManager::ResetCounterWhenRunEnds ( G4bool  resetCounterWhenRunEnds )

inline

Definition at line 211 of file G4DNAChemistryManager.hh.

  {
    fResetCounterWhenRunEnds = resetCounterWhenRunEnds;
  }

void G4DNAChemistryManager::Run

(

)

Definition at line 293 of file G4DNAChemistryManager.cc.

{
  if (fActiveChemistry)
  {
    InitializeThread();

    if (fMasterInitialized == false)
    {
      G4ExceptionDescription description;
      description << "Global components were not initialized.";
      G4Exception("G4DNAChemistryManager::Run", "MASTER_INIT", FatalException,
                  description);
    }

    if (fpgThreadInitialized_tl == 0)
    {
      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();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::SetBuildPhysicsTable ( bool  flag )

inline

Definition at line 203 of file G4DNAChemistryManager.hh.

  {fBuildPhysicsTable = flag;}

void G4DNAChemistryManager::SetChemistryActivation

(

G4bool

flag

)

Definition at line 510 of file G4DNAChemistryManager.cc.

{
  fActiveChemistry = flag;
}

void G4DNAChemistryManager::SetChemistryList ( G4VUserChemistryList *  chemistryList )

inline

Definition at line 263 of file G4DNAChemistryManager.hh.

{
  fpUserChemistryList = chemistryList;
  Activated();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAChemistryManager::SetGlobalTemperature

(

double

temp_K

)

Definition at line 752 of file G4DNAChemistryManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented from G4UImessenger.

Definition at line 253 of file G4DNAChemistryManager.cc.

{
  if (command == fpActivateChem)
  {
    Activated(G4UIcmdWithABool::GetNewBoolValue(value));
  }
  else if (command == fpRunChem)
  {
    Run();
  }
  /*
  else if(command == fpGridSize)
  {
    fDefaultGridResolution = fpGridSize->ConvertToDimensionedDouble(value);
  }*/
  else if (command == fpSkipReactionsFromChemList)
  {
    fSkipReactions = true;
  }
  else if(command == fpScaleForNewTemperature)
  {
    SetGlobalTemperature(fpScaleForNewTemperature->ConvertToDimensionedDouble(value));
  }
  else if(command == fpInitChem)
  {
    Initialize();
    InitializeThread();
  }
}

Here is the call graph for this function:

void G4DNAChemistryManager::SetVerbose ( G4int  verbose )

inline

Definition at line 198 of file G4DNAChemistryManager.hh.

  {
    fVerbose = verbose;
  }

void G4DNAChemistryManager::TagThreadForReinitialization ( )

inline

Definition at line 286 of file G4DNAChemistryManager.hh.

{
  if (fpgThreadInitialized_tl) delete fpgThreadInitialized_tl;
}

void G4DNAChemistryManager::WriteInto	(	const G4String &	,
		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 515 of file G4DNAChemistryManager.cc.

{
  if (fVerbose)
  {
    G4cout << "G4DNAChemistryManager: Write chemical stage into "
           << output.data() << G4endl;
  }

  fpgOutput_tl = new std::ofstream();
  fpgOutput_tl->open(output.data(), mode);
  fWriteFile = true;
  fFileInitialized = false;
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/source/processes/electromagnetic/dna/utils/include/G4DNAChemistryManager.hh
• source/geant4.10.03.p03/source/processes/electromagnetic/dna/utils/src/G4DNAChemistryManager.cc