Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4DNAMolecularReactionTable.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: G4DNAMolecularReactionTable.cc 95948 2016-03-03 10:40:33Z gcosmo $
27 //
28 // Author: Mathieu Karamitros (kara (AT) 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 <iomanip>
40 
42 #include "G4PhysicalConstants.hh"
43 #include "G4SystemOfUnits.hh"
44 #include "G4UIcommand.hh"
45 #include "G4VDNAReactionModel.hh"
47 #include "G4MoleculeTable.hh"
50 #include "G4IosFlagsSaver.hh"
51 #include "G4Exp.hh"
52 
53 using namespace std;
54 
56 
58  fReactant1(),
59  fReactant2(),
60  fObservedReactionRate(0.),
61  fEffectiveReactionRadius(0.),
62  fProducts(0)
63 {
64  fReactionID = 0;
65 }
66 
67 //______________________________________________________________________________
68 
71  G4MolecularConfiguration* reactant1,
72  G4MolecularConfiguration* reactant2) :
73  fProducts(0)
74 {
75  fObservedReactionRate = reactionRate;
76  SetReactant1(reactant1);
77  SetReactant2(reactant2);
78 
79  G4double sumDiffCoeff(0.);
80 
81  if (reactant1 == reactant2)
82  {
83  sumDiffCoeff = reactant1->GetDiffusionCoefficient();
85  / (4 * pi * sumDiffCoeff * Avogadro);
86  }
87  else
88  {
89  sumDiffCoeff = reactant1->GetDiffusionCoefficient()
90  + reactant2->GetDiffusionCoefficient();
92  (4 * pi * sumDiffCoeff * Avogadro);
93  }
94  fReactionID = 0;
95 }
96 
97 //______________________________________________________________________________
98 
101  const G4String& reactant1,
102  const G4String& reactant2) :
103  fProducts(0)
104 {
105  fObservedReactionRate = reactionRate;
106  SetReactant1(reactant1);
107  SetReactant2(reactant2);
108 
109  G4double sumDiffCoeff(0.);
110 
111  if (fReactant1 == fReactant2)
112  {
113  sumDiffCoeff = fReactant1->GetDiffusionCoefficient();
115  / (4 * pi * sumDiffCoeff * Avogadro);
116  }
117  else
118  {
119  sumDiffCoeff = fReactant1->GetDiffusionCoefficient()
122  (4 * pi * sumDiffCoeff * Avogadro);
123  }
124  fReactionID = 0;
125 }
126 
128 {
129  if (fProducts)
130  {
131  fProducts->clear();
132  delete fProducts;
133  fProducts = 0;
134  }
135 }
136 
138 {
139  fReactant1 = reactive;
140 }
141 
142 
144 {
145  fReactant2 = reactive;
146 }
147 
149  G4MolecularConfiguration* reactant2)
150 {
151  fReactant1 = reactant1;
152  fReactant2 = reactant2;
153 }
154 
156 {
157  if (!fProducts) fProducts = new std::vector<G4MolecularConfiguration*>();
158  fProducts->push_back(molecule);
159 }
160 
162 {
164 }
166 {
168 }
170  const G4String& reactant2)
171 {
174 }
175 
177 {
178  if (!fProducts) fProducts = new std::vector<G4MolecularConfiguration*>();
179  fProducts->push_back(G4MoleculeTable::Instance()->GetConfiguration(molecule));
180 }
181 
182 
183 double G4DNAMolecularReactionData::PolynomialParam(double temp_K, std::vector<double> P)
184  {
185  double inv_temp = 1. / temp_K;
186 
187  return pow(10,
188  P[0] + P[1] * inv_temp + P[2] * pow(inv_temp, 2)
189  + P[3] * pow(inv_temp, 3) + P[4] * pow(inv_temp, 4))
190  * (1e-3 * CLHEP::m3 / (CLHEP::mole * CLHEP::s));
191  }
192 
193  double G4DNAMolecularReactionData::ArrehniusParam(double temp_K, std::vector<double> P)
194  {
195  return P[0]*G4Exp(P[1]/temp_K)*
196  (1e-3 * CLHEP::m3 / (CLHEP::mole * CLHEP::s));
197  }
198 
200  double temp_init,
201  double rateCste_init)
202  {
203  double D0 = G4MolecularConfiguration::DiffCoeffWater(temp_init);
204  double Df = G4MolecularConfiguration::DiffCoeffWater(temp_K);
205  return Df*rateCste_init/D0;
206  }
207 
208 //==============================================================================
209 // REACTION TABLE
210 //==============================================================================
211 
213 {
214  if (!fInstance)
215  {
217  }
218  return fInstance;
219 }
220 
221 //_____________________________________________________________________________________
222 
224 {
225  if (!fInstance)
226  {
228  }
229  return fInstance;
230 }
231 
232 //_____________________________________________________________________________________
233 
235 {
236  // DEBUG
237 // G4cout << "G4MolecularReactionTable::DeleteInstance" << G4endl;
238  if (fInstance) delete fInstance;
239  fInstance = 0;
240 }
241 
242 //_____________________________________________________________________________________
243 
246 // , fMoleculeHandleManager(G4MoleculeHandleManager::Instance())
247 {
248 // G4cout << "G4DNAMolecularReactionTable::G4DNAMolecularReactionTable()" << G4endl;
249  fVerbose = false;
251  return;
252 }
253 
254 //_____________________________________________________________________________________
255 
257 {
258  // DEBUG
259 // G4cout << "G4MolecularReactionTable::~G4MolecularReactionTable" << G4endl;
260 
261  if(fpMessenger) delete fpMessenger;
262 
263  ReactionDataMap::iterator it1 = fReactionData.begin();
264  std::map<G4MolecularConfiguration*,
265  const G4DNAMolecularReactionData*>::iterator it2;
266 
267  for(; it1 != fReactionData.end(); it1++)
268  {
269  for(it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
270  {
271  const G4DNAMolecularReactionData* reactionData = it2->second;
272  if(reactionData)
273  {
274  G4MolecularConfiguration* reactant1 =
275  reactionData->GetReactant1();
276  G4MolecularConfiguration* reactant2 =
277  reactionData->GetReactant2();
278 
279  fReactionData[reactant1][reactant2] = 0;
280  fReactionData[reactant2][reactant1] = 0;
281 
282  delete reactionData;
283  }
284  }
285  }
286 
287  fReactionDataMV.clear();
288  fReactionData.clear();
289  fReactantsMV.clear();
290 }
291 
292 //_____________________________________________________________________________________
293 
295 {
296  G4MolecularConfiguration* reactant1 = reactionData->GetReactant1();
297  G4MolecularConfiguration* reactant2 = reactionData->GetReactant2();
298 
299  fReactionData[reactant1][reactant2] = reactionData;
300  fReactantsMV[reactant1].push_back(reactant2);
301  fReactionDataMV[reactant1].push_back(reactionData);
302 
303  if (reactant1 != reactant2)
304  {
305  fReactionData[reactant2][reactant1] = reactionData;
306  fReactantsMV[reactant2].push_back(reactant1);
307  fReactionDataMV[reactant2].push_back(reactionData);
308  }
309 
310  fVectorOfReactionData.push_back(reactionData);
311 }
312 
313 //_____________________________________________________________________________________
314 
316  G4MolecularConfiguration* reactant1,
317  G4MolecularConfiguration* reactant2)
318 {
320  reactionRate, reactant1, reactant2);
321  SetReaction(reactionData);
322 }
323 
324 //_____________________________________________________________________________________
325 
327 {
328  // Print Reactions and Interaction radius for jump step = 3ps
329 
330  G4IosFlagsSaver iosfs(G4cout);
331 
332  if (pReactionModel)
333  {
334  if (!(pReactionModel->GetReactionTable())) pReactionModel->SetReactionTable(
335  this);
336  }
337 
338  ReactivesMV::iterator itReactives;
339 
340  map<G4MolecularConfiguration*, map<G4MolecularConfiguration*, G4bool> > alreadyPrint;
341 
342  G4cout << "Number of chemical species involved in reactions = "
343  << fReactantsMV.size() << G4endl;
344 
345  G4int nbPrintable = fReactantsMV.size() * fReactantsMV.size();
346 
347  G4String *outputReaction = new G4String[nbPrintable];
348  G4String *outputReactionRate = new G4String[nbPrintable];
349  G4String *outputRange = new G4String[nbPrintable];
350  G4int n = 0;
351 
352  for (itReactives = fReactantsMV.begin(); itReactives != fReactantsMV.end();
353  itReactives++)
354  {
355  G4MolecularConfiguration* moleculeA = (G4MolecularConfiguration*) itReactives->first;
356  const vector<G4MolecularConfiguration*>* reactivesVector = CanReactWith(moleculeA);
357 
358  if (pReactionModel) pReactionModel->InitialiseToPrint(moleculeA);
359 
360  G4int nbReactants = fReactantsMV[itReactives->first].size();
361 
362  for (G4int iReact = 0; iReact < nbReactants; iReact++)
363  {
364 
365  G4MolecularConfiguration* moleculeB = (G4MolecularConfiguration*) (*reactivesVector)[iReact];
366 
367  const G4DNAMolecularReactionData* reactionData =
368  fReactionData[moleculeA][moleculeB];
369 
370  //-----------------------------------------------------------
371  // Name of the reaction
372  if (!alreadyPrint[moleculeA][moleculeB])
373  {
374  outputReaction[n] = moleculeA->GetName() + " + " + moleculeB->GetName();
375 
376  G4int nbProducts = reactionData->GetNbProducts();
377 
378  if (nbProducts)
379  {
380  outputReaction[n] += " -> " + reactionData->GetProduct(0)->GetName();
381 
382  for (G4int j = 1; j < nbProducts; j++)
383  {
384  outputReaction[n] += " + " + reactionData->GetProduct(j)->GetName();
385  }
386  }
387  else
388  {
389  outputReaction[n] += " -> No product";
390  }
391 
392  //-----------------------------------------------------------
393  // Interaction Rate
394  outputReactionRate[n] = G4UIcommand::ConvertToString(
395  reactionData->GetObservedReactionRateConstant() / (1e-3 * m3 / (mole * s)));
396 
397  //-----------------------------------------------------------
398  // Calculation of the Interaction Range
399  G4double interactionRange = -1;
400  if (pReactionModel) interactionRange =
401  pReactionModel->GetReactionRadius(iReact);
402 
403  if (interactionRange != -1)
404  {
405  outputRange[n] = G4UIcommand::ConvertToString(
406  interactionRange / nanometer);
407  }
408  else
409  {
410  outputRange[n] = "";
411  }
412 
413  alreadyPrint[moleculeB][moleculeA] = TRUE;
414  n++;
415  }
416  }
417  }
418  // G4cout<<"Number of possible reactions: "<< n << G4endl;
419 
421  // Tableau dynamique en fonction du nombre de caractere maximal dans
422  // chaque colonne
424 
425  G4int maxlengthOutputReaction = -1;
426  G4int maxlengthOutputReactionRate = -1;
427 
428  for (G4int i = 0; i < n; i++)
429  {
430  if (maxlengthOutputReaction < (G4int) outputReaction[i].length())
431  {
432  maxlengthOutputReaction = outputReaction[i].length();
433  }
434  if (maxlengthOutputReactionRate < (G4int) outputReactionRate[i].length())
435  {
436  maxlengthOutputReactionRate = outputReactionRate[i].length();
437  }
438  }
439 
440  maxlengthOutputReaction += 2;
441  maxlengthOutputReactionRate += 2;
442 
443  if (maxlengthOutputReaction < 10) maxlengthOutputReaction = 10;
444  if (maxlengthOutputReactionRate < 30) maxlengthOutputReactionRate = 30;
445 
446  G4String* title;
447 
448  if (pReactionModel) title = new G4String[3];
449  else title = new G4String[2];
450 
451  title[0] = "Reaction";
452  title[1] = "Reaction Rate [dm3/(mol*s)]";
453 
454  if (pReactionModel) title[2] =
455  "Interaction Range for chosen reaction model [nm]";
456 
457  G4cout << setfill(' ') << setw(maxlengthOutputReaction) << left << title[0]
458  << setw(maxlengthOutputReactionRate) << left << title[1];
459 
460  if (pReactionModel) G4cout << setw(2) << left << title[2];
461 
462  G4cout << G4endl;
463 
464  G4cout.fill('-');
465  if (pReactionModel) G4cout.width(
466  maxlengthOutputReaction + 2 + maxlengthOutputReactionRate + 2
467  + (G4int) title[2].length());
468  else G4cout.width(maxlengthOutputReaction + 2 + maxlengthOutputReactionRate);
469  G4cout << "-" << G4endl;
470  G4cout.fill(' ');
471 
472  for (G4int i = 0; i < n; i++)
473  {
474  G4cout << setw(maxlengthOutputReaction) << left << outputReaction[i]
475  << setw(maxlengthOutputReactionRate) << left
476  << outputReactionRate[i];
477 
478  if (pReactionModel) G4cout << setw(2) << left << outputRange[i];
479 
480  G4cout << G4endl;
481 
482  G4cout.fill('-');
483  if (pReactionModel) G4cout.width(
484  maxlengthOutputReaction + 2 + maxlengthOutputReactionRate + 2
485  + (G4int) title[2].length());
486  else G4cout.width(
487  maxlengthOutputReaction + 2 + maxlengthOutputReactionRate);
488  G4cout << "-" << G4endl;
489  G4cout.fill(' ');
490  }
491 
492  delete[] title;
493  delete[] outputReaction;
494  delete[] outputReactionRate;
495  delete[] outputRange;
496 }
497 
498 //______________________________________________________________________________
499 // Get/Set methods
500 
503  G4MolecularConfiguration* reactant2) const
504 {
505  if (fReactionData.empty())
506  {
507  G4String errMsg = "No reaction table was implemented";
508  G4Exception("G4MolecularInteractionTable::GetReactionData", "",
509  FatalErrorInArgument, errMsg);
510  return 0;
511  }
512 
513  ReactionDataMap::const_iterator it1 = fReactionData.find(reactant1);
514 
515  if (it1 == fReactionData.end())
516  {
517  G4String errMsg =
518  "No reaction table was implemented for this molecule Definition : " + reactant1
519  ->GetName();
520 // G4cout << "--- G4MolecularInteractionTable::GetReactionData ---" << G4endl;
521 // G4cout << errMsg << G4endl;
522  G4Exception("G4MolecularInteractionTable::GetReactionData", "",
523  FatalErrorInArgument, errMsg);
524 // return 0;
525  }
526 
527  std::map<G4MolecularConfiguration*,
528  const G4DNAMolecularReactionData*>::const_iterator it2 =
529  it1->second.find(reactant2);
530 
531  if (it2 == it1->second.end())
532  {
533  G4cout << "Name : " << reactant2->GetName() << G4endl;
534  G4String errMsg = "No reaction table was implemented for this molecule : "
535  + reactant2 -> GetName();
536  G4Exception("G4MolecularInteractionTable::GetReactionData","",FatalErrorInArgument, errMsg);
537  }
538 
539  return (it2->second);
540 }
541 
542 //______________________________________________________________________________
543 
544 const std::vector<G4MolecularConfiguration*>*
546 {
547  if (fReactantsMV.empty())
548  {
549  G4String errMsg = "No reaction table was implemented";
550  G4Exception("G4MolecularInteractionTable::CanReactWith", "",
551  FatalErrorInArgument, errMsg);
552  return 0;
553  }
554 
555  ReactivesMV::const_iterator itReactivesMap = fReactantsMV.find(aMolecule);
556 
557  if (itReactivesMap == fReactantsMV.end())
558  {
559 #ifdef G4VERBOSE
560  if (fVerbose)
561  {
562  G4String errMsg = "No reaction table was implemented for this molecule : "
563  + aMolecule->GetName();
564 // G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
565  G4cout << "--- G4MolecularInteractionTable::GetReactionData ---" << G4endl;
566  G4cout << errMsg << G4endl;
567  }
568 #endif
569  return 0;
570  }
571  else
572  {
573  if(fVerbose)
574  {
575  G4cout<< " G4MolecularInteractionTable::CanReactWith :"<<G4endl;
576  G4cout<<"You are checking reactants for : " << aMolecule->GetName()<<G4endl;
577  G4cout<<" the number of reactants is : " << itReactivesMap->second.size()<<G4endl;
578 
579  std::vector<G4MolecularConfiguration*>::const_iterator itProductsVector =
580  itReactivesMap->second.begin();
581 
582  for(; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
583  {
584  G4cout<<(*itProductsVector)->GetName()<<G4endl;
585  }
586  }
587  return &(itReactivesMap->second);
588  }
589  return 0;
590 }
591 
592 //______________________________________________________________________________
593 
594 const std::map<G4MolecularConfiguration*, const G4DNAMolecularReactionData*>*
596 {
597  if (fReactionData.empty())
598  {
599  G4String errMsg = "No reaction table was implemented";
600  G4Exception("G4MolecularInteractionTable::CanInteractWith", "",
601  FatalErrorInArgument, errMsg);
602  return 0;
603  }
604 
605  ReactionDataMap::const_iterator itReactivesMap = fReactionData.find(molecule);
606 
607  if (itReactivesMap == fReactionData.end())
608  {
609  return 0;
610 // G4cout << "Nom : " << molecule->GetName() << G4endl;
611 // G4String errMsg = "No reaction table was implemented for this molecule Definition : "
612 // + molecule -> GetName();
613 // G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
614  }
615  else
616  {
617  if(fVerbose)
618  {
619  G4cout<< " G4MolecularInteractionTable::CanReactWith :"<<G4endl;
620  G4cout<<"You are checking reactants for : " << molecule->GetName()<<G4endl;
621  G4cout<<" the number of reactants is : " << itReactivesMap->second.size()<<G4endl;
622 
623  std::map<G4MolecularConfiguration*,
624  const G4DNAMolecularReactionData*>::const_iterator itProductsVector =
625  itReactivesMap->second.begin();
626 
627  for(; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
628  {
629  G4cout<<itProductsVector->first->GetName()<<G4endl;
630  }
631  }
632  return &(itReactivesMap->second);
633  }
634 
635  return 0;
636 }
637 
638 //______________________________________________________________________________
639 
640 const std::vector<const G4DNAMolecularReactionData*>*
642 {
643  if (fReactionDataMV.empty())
644  {
645  G4String errMsg = "No reaction table was implemented";
646  G4Exception("G4MolecularInteractionTable::CanInteractWith", "",
647  FatalErrorInArgument, errMsg);
648  return 0;
649  }
650  ReactionDataMV::const_iterator it = fReactionDataMV.find(molecule);
651 
652  if (it == fReactionDataMV.end())
653  {
654  G4cout << "Nom : " << molecule->GetName() << G4endl;
655  G4String errMsg = "No reaction table was implemented for this molecule Definition : "
656  + molecule -> GetName();
657  G4Exception("G4MolecularInteractionTable::GetReactionData","",FatalErrorInArgument, errMsg);
658  return 0; // coverity
659  }
660 
661  return &(it->second);
662 }
663 
664 //______________________________________________________________________________
665 
668  const G4String& mol2) const
669 {
671  ->GetConfiguration(mol1);
673  ->GetConfiguration(mol2);
674 
675  return GetReactionData(conf1, conf2);
676 }
677 
678 //______________________________________________________________________________
679 
680 void
682 SetPolynomialParameterization(const std::vector<double>& P)
683 {
684  fRateParam = std::bind(PolynomialParam, std::placeholders::_1, P);
685 }
686 
687 //______________________________________________________________________________
688 
690  double E_R)
691 {
692  std::vector<double> P = {A0, E_R};
693 
694  G4cout << "ici = " << P[0] << G4endl;
695  G4cout << "A0 = " << A0 << G4endl;
696 
697  fRateParam = std::bind(ArrehniusParam, std::placeholders::_1, P);
698 }
699 
700 //______________________________________________________________________________
701 
703  double rateCste)
704 {
705  fRateParam = std::bind(ScaledParameterization,
706  std::placeholders::_1,
707  temperature_K,
708  rateCste);
709 }
710 
711 //______________________________________________________________________________
712 
714 {
715  size_t end = fVectorOfReactionData.size();
716 
717  for(size_t i = 0 ; i < end ; ++i)
718  {
720  ScaleForNewTemperature(temp_K);
721  }
722 }
723 
724 //______________________________________________________________________________
725 
727 {
728  if(fRateParam)
729  {
731 
732 // G4cout <<"PROD RATE = " << fProductionRate << G4endl;
733 //
734 // if(fProductionRate != DBL_MAX && fProductionRate !=0)
735 // {
736 // SetPartiallyDiffusionControlledReactionByActivation(fObservedReactionRate,
737 // fProductionRate);
738 // }
739  }
740 }
741 
742 //______________________________________________________________________________
743 
746 {
747  for(size_t i = 0 ; i < fVectorOfReactionData.size() ; ++i)
748  {
749  if(fVectorOfReactionData[i]->GetReactionID() == reactionID)
750  return fVectorOfReactionData[i];
751  }
752  return nullptr;
753 }
static constexpr double m3
const G4String & GetName() const
const G4DNAMolecularReactionData * GetReaction(int reactionID) const
static G4DNAMolecularReactionTable * Instance()
const G4DNAMolecularReactionData * GetReactionData(G4MolecularConfiguration *, G4MolecularConfiguration *) const
static double PolynomialParam(double temp_K, std::vector< double > P)
void ScaleReactionRateForNewTemperature(double temp_K)
G4ReactionTableMessenger * fpMessenger
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:372
static constexpr double nanometer
Definition: G4SIunits.hh:101
void SetReactant1(G4MolecularConfiguration *reactive)
static constexpr double m3
Definition: G4SIunits.hh:131
int G4int
Definition: G4Types.hh:78
float Avogadro
Definition: hepunit.py:253
static double P[]
static G4DNAMolecularReactionTable * GetReactionTable()
const std::map< G4MolecularConfiguration *, const G4DNAMolecularReactionData * > * GetReativesNData(G4MolecularConfiguration *) const
void SetReaction(G4double observedReactionRate, G4MolecularConfiguration *reactive1, G4MolecularConfiguration *reactive2)
const XML_Char * s
Definition: expat.h:262
G4GLOB_DLL std::ostream G4cout
void SetReactionTable(const G4DNAMolecularReactionTable *)
virtual G4double GetReactionRadius(G4MolecularConfiguration *, G4MolecularConfiguration *)=0
static double DiffCoeffWater(double temperature_K)
static G4MoleculeTable * Instance()
void SetArrehniusParameterization(double A0, double E_R)
void PrintTable(G4VDNAReactionModel *=0)
#define TRUE
Definition: globals.hh:55
G4MolecularConfiguration * fReactant1
const G4int n
void AddProduct(G4MolecularConfiguration *molecule)
static double ArrehniusParam(double temp_K, std::vector< double > P)
static constexpr double s
static G4DNAMolecularReactionTable * fInstance
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
static double ScaledParameterization(double temp_K, double temp_init, double rateCste_init)
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
void SetObservedReactionRateConstant(G4double rate)
void SetReactants(G4MolecularConfiguration *reactive1, G4MolecularConfiguration *reactive2)
std::vector< G4MolecularConfiguration * > * fProducts
void SetReactant2(G4MolecularConfiguration *reactive)
static G4MoleculeTable * GetMoleculeTable()
G4MolecularConfiguration * GetReactant1() const
void SetPolynomialParameterization(const std::vector< double > &P)
void SetScaledParameterization(double temperature_K, double rateCste)
G4MolecularConfiguration * GetReactant2() const
#define G4endl
Definition: G4ios.hh:61
G4MolecularConfiguration * fReactant2
static constexpr double pi
Definition: G4SIunits.hh:75
static constexpr double mole
const G4DNAMolecularReactionTable * GetReactionTable()
double G4double
Definition: G4Types.hh:76
std::vector< const G4DNAMolecularReactionData * > fVectorOfReactionData
subroutine title
Definition: hijing1.383.f:5980
static constexpr double mole
Definition: G4SIunits.hh:286
const std::vector< G4MolecularConfiguration * > * CanReactWith(G4MolecularConfiguration *) const
G4MolecularConfiguration * GetProduct(G4int i) const
virtual void InitialiseToPrint(G4MolecularConfiguration *)=0
G4MolecularConfiguration * GetConfiguration(const G4String &, bool mustExist=true)