Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4DNAChemistryManager.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id: G4DNAChemistryManager.cc 100802 2016-11-02 14:55:27Z gcosmo $
27 //
28 // Author: Mathieu Karamitros (kara@cenbg.in2p3.fr)
29 //
30 // WARNING : This class is released as a prototype.
31 // It might strongly evolve or even disapear in the next releases.
32 //
33 // History:
34 // -----------
35 // 10 Oct 2011 M.Karamitros created
36 //
37 // -------------------------------------------------------------------
38 
39 #include "G4DNAChemistryManager.hh"
40 
41 #include "G4Scheduler.hh"
42 #include "G4SystemOfUnits.hh"
43 #include "G4Molecule.hh"
44 #include "G4VITTrackHolder.hh"
45 #include "G4H2O.hh"
49 #include "G4Electron_aq.hh"
51 #include "G4VMoleculeCounter.hh"
52 #include "G4VUserChemistryList.hh"
53 #include "G4AutoLock.hh"
54 #include "G4UIcmdWithABool.hh"
57 #include "G4GeometryManager.hh"
58 #include "G4StateManager.hh"
59 #include "G4MoleculeFinder.hh"
60 #include "G4MoleculeTable.hh"
61 
62 using namespace std;
63 
64 G4DNAChemistryManager* G4DNAChemistryManager::fgInstance;
65 G4ThreadLocal std::ofstream* G4DNAChemistryManager::fpgOutput_tl = 0;
66 G4ThreadLocal G4bool* G4DNAChemistryManager::fpgThreadInitialized_tl = 0;
68 //bool G4DNAChemistryManager::fActiveChemistry = false;
69 
72 {
73 //==============================================================================
74 /* M.K: 24/11/2014
75  * To work properly, the chemistry manager should be created and initialized on
76  * the master thread only. If the static flag fActiveChemistry is on but the
77  * chemistry manager singleton
78  */
79 //==============================================================================
80 
81 // if (/*fActiveChemistry &&*/ G4Threading::IsWorkerThread()
82 // && G4Threading::IsMultithreadedApplication())
83 // {
84 // G4Exception("G4DNAChemistryManager::G4DNAChemistryManager",
85 // "G4DNAChemistryManager_MASTER_CREATION", FatalException,
86 // "The chemistry manager should be created and initialized on the "
87 // "master thread only");
88 // }
89 
90  fpExcitationLevel = 0;
91  fpIonisationLevel = 0;
92  fWriteFile = false;
93  fpUserChemistryList = 0;
94  fMasterInitialized = false;
95  fpChemDNADirectory = new G4UIdirectory("/chem/");
96  fpActivateChem = new G4UIcmdWithABool("/chem/activate", this);
97  fpRunChem = new G4UIcmdWithoutParameter("/chem/run", this);
98  //fpGridSize = new G4UIcmdWithADoubleAndUnit("/chem/gridRes", this);
99  fpScaleForNewTemperature = new G4UIcmdWithADoubleAndUnit("/chem/temperature",
100  this);
101  fpSkipReactionsFromChemList =
102  new G4UIcmdWithoutParameter("/chem/skipReactionsFromChemList", this);
103  fpInitChem = new G4UIcmdWithoutParameter("/chem/init", this);
104  //fDefaultGridResolution = -1;
105  fBuildPhysicsTable = false;
106  fGeometryClosed = false;
107  fPhysicsTableBuilt = false;
108  fForceThreadReinitialization = false;
109  fFileInitialized = false;
110  fVerbose = 0;
111  fActiveChemistry = false;
112  fSkipReactions = false;
113  fResetCounterWhenRunEnds = true;
114 }
115 
118 {
119  if (fgInstance == 0)
120  {
122  if (fgInstance == 0) // MT : double check at initialisation
123  {
124  fgInstance = new G4DNAChemistryManager();
125  }
126  lock.unlock();
127  }
128  return fgInstance;
129 }
130 
133 {
134  return fgInstance;
135 }
136 
138 {
139 // G4cout << "Deleting G4DNAChemistryManager" << G4endl;
140  Clear();
141  fgInstance = 0;
142  /*
143  * DEBUG : check that the chemistry manager has well been deregistered
144  * assert(G4StateManager::GetStateManager()->
145  * DeregisterDependent(this) == true);
146  */
147 }
148 
150 {
151  if (fpIonisationLevel)
152  {
153  delete fpIonisationLevel;
154  fpIonisationLevel = 0;
155 
156  }
157  if (fpExcitationLevel)
158  {
159  delete fpExcitationLevel;
160  fpExcitationLevel = 0;
161  }
162  if (fpUserChemistryList)
163  {
164  if(fpUserChemistryList->IsPhysicsConstructor() == false)
165  {
166  delete fpUserChemistryList;
167  }
168 // else
169 // {
170 // G4cout << "G4DNAChemistryManager will not delete the chemistry list "
171 // "since it inherits from G4VPhysicsConstructor and it is then "
172 // "expected to be the responsability to the G4VModularPhysics to handle"
173 // " the chemistry list." << G4endl;
174 // }
175  fpUserChemistryList = 0;
176  }
177  if (fpChemDNADirectory)
178  {
179  delete fpChemDNADirectory;
180  fpChemDNADirectory = 0;
181  }
182  if (fpActivateChem)
183  {
184  delete fpActivateChem;
185  fpActivateChem = 0;
186  }
187  if(fpRunChem)
188  {
189  delete fpRunChem;
190  fpRunChem = 0;
191  }
192  if(fpSkipReactionsFromChemList)
193  {
194  delete fpSkipReactionsFromChemList;
195  fpSkipReactionsFromChemList = 0;
196  }
197  if(fpInitChem)
198  {
199  delete fpInitChem;
200  fpInitChem = 0;
201  }
202 
204  //G4MoleculeHandleManager::DeleteInstance();
207 }
208 
210 {
211  //G4cout << "G4DNAChemistryManager::DeleteInstance" << G4endl;
212 
214 
215  if(fgInstance)
216  {
217  G4DNAChemistryManager* deleteMe = fgInstance;
218  fgInstance = 0;
219  lock.unlock();
220  delete deleteMe;
221  }
222  else
223  {
224  G4cout << "G4DNAChemistryManager already deleted" << G4endl;
225  }
226  lock.unlock();
227 }
228 
230 {
231  if (requestedState == G4State_Quit)
232  {
233  if(fVerbose)
234  G4cout << "G4DNAChemistryManager::Notify ---> received G4State_Quit"
235  << G4endl;
236  //DeleteInstance();
237  Clear();
238  }
239 
240  else if(requestedState == G4State_GeomClosed)
241  {
242  fGeometryClosed = true;
243  }
244 
245  else if (requestedState == G4State_Idle)
246  {
248  }
249 
250  return true;
251 }
252 
254 {
255  if (command == fpActivateChem)
256  {
258  }
259  else if (command == fpRunChem)
260  {
261  Run();
262  }
263  /*
264  else if(command == fpGridSize)
265  {
266  fDefaultGridResolution = fpGridSize->ConvertToDimensionedDouble(value);
267  }*/
268  else if (command == fpSkipReactionsFromChemList)
269  {
270  fSkipReactions = true;
271  }
272  else if(command == fpScaleForNewTemperature)
273  {
274  SetGlobalTemperature(fpScaleForNewTemperature->ConvertToDimensionedDouble(value));
275  }
276  else if(command == fpInitChem)
277  {
278  Initialize();
280  }
281 }
282 
284 {
285  if (command == fpActivateChem)
286  {
287  return G4UIcmdWithABool::ConvertToString(fActiveChemistry);
288  }
289 
290  return "";
291 }
292 
294 {
295  if (fActiveChemistry)
296  {
298 
299  if (fMasterInitialized == false)
300  {
301  G4ExceptionDescription description;
302  description << "Global components were not initialized.";
303  G4Exception("G4DNAChemistryManager::Run", "MASTER_INIT", FatalException,
304  description);
305  }
306 
307  if (fpgThreadInitialized_tl == 0)
308  {
309  G4ExceptionDescription description;
310  description << "Thread local components were not initialized.";
311  G4Exception("G4DNAChemistryManager::Run", "THREAD_INIT", FatalException,
312  description);
313  }
314 
317  if(fResetCounterWhenRunEnds)
318  {
320  }
321  CloseFile();
322  }
323 }
324 
325 void G4DNAChemistryManager::Gun(G4ITGun* gun, bool physicsTableToBuild)
326 {
327  fBuildPhysicsTable = physicsTableToBuild;
329 }
330 
332 {
333  //===========================================================================
334  // MT MODE
335  //===========================================================================
337  {
338  //==========================================================================
339  // ON WORKER THREAD
340  //==========================================================================
342  {
343  InitializeThread(); // Will create and initialize G4ITScheduler
344  return;
345  }
346  //==========================================================================
347  // ON MASTER THREAD
348  //==========================================================================
349  else
350  {
352  return;
353  }
354  }
355  //===========================================================================
356  // IS NOT IN MT MODE
357  //===========================================================================
358  else
359  {
361  // In this case: InitializeThread is called when Run() is called
362  return;
363  }
364 
365 }
366 
368 {
369  if (fMasterInitialized == false)
370  {
371  if(fVerbose)
372  {
373  G4cout << "G4DNAChemistryManager::InitializeMaster() is called" << G4endl;
374  }
375 
377  // creates a concrete object of the scheduler
378  // and track container
379 
380  if (fpUserChemistryList)
381  {
382  fpUserChemistryList->ConstructDissociationChannels();
383  if(fSkipReactions == false)
384  {
385  fpUserChemistryList->ConstructReactionTable(
387  }
388  else
389  {
391  }
392  fMasterInitialized = true;
393  }
394  else
395  {
396  if (fActiveChemistry)
397  {
398  G4ExceptionDescription description;
399  description << "No user chemistry list has been provided.";
400  G4Exception("G4DNAChemistryManager::InitializeMaster", "NO_CHEM_LIST",
401  FatalException, description);
402  }
403  }
404  }
405 }
406 
408 {
409  if (fpgThreadInitialized_tl == 0 || fForceThreadReinitialization == true)
410  {
411  if (fpUserChemistryList)
412  {
413  if(fVerbose)
414  {
415  G4cout << "G4DNAChemistryManager::InitializeThread() is called"
416  << G4endl;
417  }
418 
419  if (fBuildPhysicsTable && fPhysicsTableBuilt == false)
420  {
421  if(fVerbose)
422  {
423  G4cout << "G4DNAChemistryManager: Build the physics tables for "
424  "molecules."
425  << G4endl;
426  }
427 
428  fpUserChemistryList->BuildPhysicsTable();
429  if (fGeometryClosed == false)
430  {
431  if(fVerbose)
432  {
433  G4cout << "G4DNAChemistryManager: Close geometry"
434  << G4endl;
435  }
436 
438  // G4cout << "Start closing geometry." << G4endl;
439  geomManager->OpenGeometry();
440  geomManager->CloseGeometry(true, true);
441  fGeometryClosed = true;
442  }
443 
444  fPhysicsTableBuilt = true;
445  }
446  fpUserChemistryList->ConstructTimeStepModel(
449 
450  fpgThreadInitialized_tl = new G4bool(true);
451  }
452  else
453  {
454  G4ExceptionDescription description;
455  description << "No user chemistry list has been provided.";
456  G4Exception("G4DNAChemistryManager::InitializeThread", "NO_CHEM_LIST",
457  FatalException, description);
458  }
459 
461  }
462 
463  InitializeFile();
464 }
465 
467 {
468  if (fpgOutput_tl == 0 || fWriteFile == false || fFileInitialized)
469  {
470  return;
471  }
472 
473  if(fVerbose)
474  {
475  G4cout << "G4DNAChemistryManager::InitializeFile() is called"
476  << G4endl;
477  }
478 
479  *fpgOutput_tl << std::setprecision(6) << std::scientific;
480  *fpgOutput_tl << setw(11) << left << "#Parent ID" << setw(10) << "Molecule"
481  << setw(14) << "Elec Modif" << setw(13) << "Energy (eV)"
482  << setw(22) << "X pos of parent [nm]" << setw(22)
483  << "Y pos of parent [nm]" << setw(22) << "Z pos of parent [nm]"
484  << setw(14) << "X pos [nm]" << setw(14) << "Y pos [nm]"
485  << setw(14) << "Z pos [nm]" << G4endl<< setw(21) << "#"
486  << setw(13) << "1)io/ex=0/1"
487  << G4endl
488  << setw(21) << "#"
489  << setw(13) << "2)level=0...5"
490  << G4endl;
491 
492  fFileInitialized = true;
493 }
494 
496 {
497  return Instance()->fActiveChemistry;
498 }
499 
501 {
502  Instance()->fActiveChemistry = flag;
503 }
504 
506 {
507  return fActiveChemistry;
508 }
509 
511 {
512  fActiveChemistry = flag;
513 }
514 
516  ios_base::openmode mode)
517 {
518  if (fVerbose)
519  {
520  G4cout << "G4DNAChemistryManager: Write chemical stage into "
521  << output.data() << G4endl;
522  }
523 
524  fpgOutput_tl = new std::ofstream();
525  fpgOutput_tl->open(output.data(), mode);
526  fWriteFile = true;
527  fFileInitialized = false;
528 }
529 
531 {
532  if (fWriteFile)
533  {
534  *fpgOutput_tl << G4endl;
535  }
536 }
537 
539 {
540  if (fpgOutput_tl == 0) return;
541 
542  if (fpgOutput_tl->is_open())
543  {
544  if (fVerbose)
545  {
546  G4cout << "G4DNAChemistryManager: Close File" << G4endl;
547  }
548  fpgOutput_tl->close();
549  }
550 }
551 
554 {
555  if (!fpExcitationLevel)
556  {
557  fpExcitationLevel = new G4DNAWaterExcitationStructure;
558  }
559  return fpExcitationLevel;
560 }
561 
564 {
565  if (!fpIonisationLevel)
566  {
567  fpIonisationLevel = new G4DNAWaterIonisationStructure;
568  }
569  return fpIonisationLevel;
570 }
571 
573  G4int electronicLevel,
574  const G4Track* theIncomingTrack)
575 {
576  if (fWriteFile)
577  {
578  if(!fFileInitialized) InitializeFile();
579 
580  G4double energy = -1.;
581 
582  switch (modification)
583  {
585  energy = 0;
586  break;
587  case eExcitedMolecule:
588  energy = GetExcitationLevel()->ExcitationEnergy(electronicLevel);
589  break;
590  case eIonizedMolecule:
591  energy = GetIonisationLevel()->IonisationEnergy(electronicLevel);
592  break;
593  }
594 
595  *fpgOutput_tl << setw(11) << left << theIncomingTrack->GetTrackID()
596  << setw(10) << "H2O" << left << modification << internal
597  << ":" << right << electronicLevel << left << setw(11) << ""
598  << std::setprecision(2) << std::fixed << setw(13)
599  << energy / eV << std::setprecision(6) << std::scientific
600  << setw(22)
601  << (theIncomingTrack->GetPosition().x()) / nanometer
602  << setw(22)
603  << (theIncomingTrack->GetPosition().y()) / nanometer
604  << setw(22)
605  << (theIncomingTrack->GetPosition().z()) / nanometer
606  << G4endl;
607  }
608 
609  if(fActiveChemistry)
610  {
611  G4Molecule * H2O = new G4Molecule (G4H2O::Definition());
612 
613  switch (modification)
614  {
616  H2O -> AddElectron(5,1);
617  break;
618  case eExcitedMolecule :
619  H2O -> ExciteMolecule(4-electronicLevel);
620  break;
621  case eIonizedMolecule :
622  H2O -> IonizeMolecule(4-electronicLevel);
623  break;
624  }
625 
626  G4Track * H2OTrack = H2O->BuildTrack(1*picosecond,
627  theIncomingTrack->GetPosition());
628 
629  H2OTrack -> SetParentID(theIncomingTrack->GetTrackID());
630  H2OTrack -> SetTrackStatus(fStopButAlive);
631  H2OTrack -> SetKineticEnergy(0.);
632  G4VITTrackHolder::Instance()->Push(H2OTrack);
633  }
634 // else
635 // abort();
636 }
637 
639  G4ThreeVector* finalPosition)
640 // finalPosition is a pointer because this argument is optional
641 {
642  if (fWriteFile)
643  {
644  if(!fFileInitialized) InitializeFile();
645 
646  *fpgOutput_tl << setw(11) << theIncomingTrack->GetTrackID() << setw(10)
647  << "e_aq" << setw(14) << -1 << std::setprecision(2)
648  << std::fixed << setw(13)
649  << theIncomingTrack->GetKineticEnergy() / eV
650  << std::setprecision(6) << std::scientific << setw(22)
651  << (theIncomingTrack->GetPosition().x()) / nanometer
652  << setw(22)
653  << (theIncomingTrack->GetPosition().y()) / nanometer
654  << setw(22)
655  << (theIncomingTrack->GetPosition().z()) / nanometer;
656 
657  if (finalPosition != 0)
658  {
659  *fpgOutput_tl << setw(14) << (finalPosition->x()) / nanometer << setw(14)
660  << (finalPosition->y()) / nanometer << setw(14)
661  << (finalPosition->z()) / nanometer;
662  }
663 
664  *fpgOutput_tl << G4endl;
665  }
666 
667  if(fActiveChemistry)
668  {
670  G4Track * e_aqTrack(0);
671  if(finalPosition)
672  {
673  e_aqTrack = e_aq->BuildTrack(picosecond,*finalPosition);
674  }
675  else
676  {
677  e_aqTrack = e_aq->BuildTrack(picosecond,theIncomingTrack->GetPosition());
678  }
679  e_aqTrack -> SetTrackStatus(fAlive);
680  e_aqTrack -> SetParentID(theIncomingTrack->GetTrackID());
681  G4VITTrackHolder::Instance()->Push(e_aqTrack);
682  }
683 }
684 
686  double time,
687  const G4ThreeVector& position,
688  int parentID)
689 {
690  if (fWriteFile)
691  {
692  if(!fFileInitialized) InitializeFile();
693 
694  *fpgOutput_tl << setw(11) << parentID << setw(10) << molecule->GetName()
695  << setw(14) << -1 << std::setprecision(2) << std::fixed
696  << setw(13) << -1 << std::setprecision(6) << std::scientific
697  << setw(22) << (position.x()) / nanometer << setw(22)
698  << (position.y()) / nanometer << setw(22)
699  << (position.z()) / nanometer;
700  *fpgOutput_tl << G4endl;
701  }
702 
703  if(fActiveChemistry)
704  {
705  G4Track* track = molecule->BuildTrack(time,position);
706  track -> SetTrackStatus(fAlive);
707  track -> SetParentID(parentID);
709  }
710  else
711  {
712  delete molecule;
713  molecule = 0;
714  }
715 }
716 
718  const G4Track* theIncomingTrack)
719 {
720  if (fWriteFile)
721  {
722  if(!fFileInitialized) InitializeFile();
723 
724  *fpgOutput_tl << setw(11) << theIncomingTrack->GetTrackID() << setw(10)
725  << molecule->GetName() << setw(14) << -1
726  << std::setprecision(2) << std::fixed << setw(13)
727  << theIncomingTrack->GetKineticEnergy() / eV
728  << std::setprecision(6) << std::scientific << setw(22)
729  << (theIncomingTrack->GetPosition().x()) / nanometer
730  << setw(22)
731  << (theIncomingTrack->GetPosition().y()) / nanometer
732  << setw(22)
733  << (theIncomingTrack->GetPosition().z()) / nanometer;
734  *fpgOutput_tl << G4endl;
735  }
736 
737  if(fActiveChemistry)
738  {
739  G4Track* track = molecule->BuildTrack(theIncomingTrack->GetGlobalTime(),
740  theIncomingTrack->GetPosition());
741  track -> SetTrackStatus(fAlive);
742  track -> SetParentID(theIncomingTrack->GetTrackID());
744  }
745  else
746  {
747  delete molecule;
748  molecule = 0;
749  }
750 }
751 
753 {
756 }
757 
void WriteInto(const G4String &, std::ios_base::openmode mode=std::ios_base::out)
void Process()
Definition: G4Scheduler.cc:377
static G4VITTrackHolder * Instance()
void PushMoleculeAtParentTimeAndPlace(G4Molecule *&molecule, const G4Track *)
virtual void ConstructReactionTable(G4DNAMolecularReactionTable *reactionTable)=0
static G4Electron_aq * Definition()
static G4H2O * Definition()
Definition: G4H2O.cc:46
static G4DNAMolecularReactionTable * Instance()
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
double x() const
void CreateSolvatedElectron(const G4Track *, G4ThreeVector *finalPosition=0)
void ScaleReactionRateForNewTemperature(double temp_K)
const G4ThreeVector & GetPosition() const
virtual void Push(G4Track *)
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:372
static constexpr double nanometer
Definition: G4SIunits.hh:101
ElectronicModification
void Finalize(G4MoleculeDefinition *)
#define G4ThreadLocal
Definition: tls.hh:89
int G4int
Definition: G4Types.hh:78
static G4Scheduler * Instance()
Definition: G4Scheduler.cc:102
static G4bool GetNewBoolValue(const char *paramString)
static constexpr double picosecond
Definition: G4SIunits.hh:161
double z() const
static G4double ConvertToDimensionedDouble(const char *st)
Definition: G4UIcommand.cc:463
static G4DNAMolecularReactionTable * GetReactionTable()
G4DNAWaterExcitationStructure * GetExcitationLevel()
const G4String & GetName() const
Definition: G4Molecule.cc:356
G4Mutex chemManExistence
static void InitializeInstance()
G4double GetKineticEnergy() const
G4GLOB_DLL std::ostream G4cout
virtual G4bool Notify(G4ApplicationState requestedState)
const XML_Char int const XML_Char * value
Definition: expat.h:331
virtual void SetNewValue(G4UIcommand *, G4String)
void PushMolecule(G4Molecule *&molecule, double time, const G4ThreeVector &position, int parentID)
bool G4bool
Definition: G4Types.hh:79
void SetGun(G4ITGun *)
Definition: G4Scheduler.hh:423
virtual void ConstructDissociationChannels()
static G4MoleculeTable * Instance()
static constexpr double eV
Definition: G4SIunits.hh:215
void SetGlobalTemperature(double temp_K)
static void SetGlobalTemperature(G4double)
G4int GetTrackID() const
G4double GetGlobalTime() const
static G4GeometryManager * GetInstance()
G4bool IsMultithreadedApplication()
Definition: G4Threading.cc:152
static G4VMoleculeCounter * Instance()
virtual G4String GetCurrentValue(G4UIcommand *command)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4bool IsWorkerThread()
Definition: G4Threading.cc:145
G4Track * BuildTrack(G4double globalTime, const G4ThreeVector &Position)
Definition: G4Molecule.cc:391
const char * data() const
static G4DNAChemistryManager * Instance()
G4int G4Mutex
Definition: G4Threading.hh:173
G4double energy(const ThreeVector &p, const G4double m)
void CreateWaterMolecule(ElectronicModification, G4int, const G4Track *)
virtual void ResetCounter()=0
double y() const
static void DeleteInstance()
#define G4endl
Definition: G4ios.hh:61
static void Activated(G4bool flag=true)
void OpenGeometry(G4VPhysicalVolume *vol=0)
void Gun(G4ITGun *, bool physicsTableToBuild=true)
void PrepareMolecularConfiguration()
double G4double
Definition: G4Types.hh:76
virtual void ConstructTimeStepModel(G4DNAMolecularReactionTable *reactionTable)=0
static G4DNAChemistryManager * GetInstanceIfExists()
void Initialize()
Definition: G4Scheduler.cc:282
G4bool CloseGeometry(G4bool pOptimise=true, G4bool verbose=false, G4VPhysicalVolume *vol=0)
G4DNAWaterIonisationStructure * GetIonisationLevel()
G4ApplicationState