ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4MolecularConfiguration.hh
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4MolecularConfiguration.hh
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 //
27 // Author: Mathieu Karamitros
28 
29 // The code is developed in the framework of the ESA AO7146
30 //
31 // We would be very happy hearing from you, send us your feedback! :)
32 //
33 // In order for Geant4-DNA to be maintained and still open-source,
34 // article citations are crucial.
35 // If you use Geant4-DNA chemistry and you publish papers about your software,
36 // in addition to the general paper on Geant4-DNA:
37 //
38 // Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
39 //
40 // we would be very happy if you could please also cite the following
41 // reference papers on chemistry:
42 //
43 // J. Comput. Phys. 274 (2014) 841-882
44 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508
45 
46 #ifndef G4MolecularConfiguration_
47 #define G4MolecularConfiguration_ 1
48 
49 #include <vector>
50 #include <map>
51 #include "G4Threading.hh"
52 #include "G4ElectronOccupancy.hh"
53 #include <cassert>
54 #include <functional>
55 
56 class G4MolecularDissociationChannel;
57 class G4MoleculeDefinition;
58 class G4Material;
59 class G4MolecularConfiguration;
60 
61 struct comparator
62 {
63  bool operator()(const G4ElectronOccupancy& occ1,
64  const G4ElectronOccupancy& occ2) const
65  {
66  G4int totalOcc1 = occ1.GetTotalOccupancy();
67  G4int totalOcc2 = occ2.GetTotalOccupancy();
68  if (totalOcc1 != totalOcc2)
69  {
70  return totalOcc1 < totalOcc2;
71  }
72  else
73  {
74  G4int occupancy1 = -1;
75  G4int occupancy2 = -1;
76  const G4int sizeOrbit = occ1.GetSizeOfOrbit();
77  for (G4int i = 0; i < sizeOrbit; i++)
78  {
79  occupancy1 = occ1.GetOccupancy(i);
80  occupancy2 = occ2.GetOccupancy(i);
81 
82  if (occupancy1 != occupancy2)
83  {
84  return occupancy1 < occupancy2;
85  }
86  }
87  }
88  return false;
89  }
90 };
91 
98 class G4MolecularConfiguration
99 {
100 public:
101 
102  typedef std::function<double(const G4Material*,
103  double,
104  const G4MolecularConfiguration*)> G4DiffCoeffParam;
105 
106  //____________________________________________________________________________
107  // Static methods
108 
110  // CREATE FINALIZED SPECIES
111  // Get ground state electronic configuration
112  static G4MolecularConfiguration*
113  GetOrCreateMolecularConfiguration(const G4MoleculeDefinition*);
114 
115  // Get for a given moleculeDefinition and a given electronic configuration,
116  // the molecular configuration
117  static G4MolecularConfiguration*
118  GetOrCreateMolecularConfiguration(const G4MoleculeDefinition*,
119  const G4ElectronOccupancy& eOcc);
120 
121  // Get for a given moleculeDefinition and a given electronic configuration,
122  // the molecular configuration
123  static G4MolecularConfiguration*
124  GetOrCreateMolecularConfiguration(const G4MoleculeDefinition*, int charge);
125 
127  // CREATE UNFINALIZED SPECIES
128  // Create ground state electronic configuration - to be finalized
129  static G4MolecularConfiguration*
130  CreateMolecularConfiguration(const G4String& userIdentifier,
131  const G4MoleculeDefinition*,
132  bool& wasAlreadyCreated);
133 
134  static G4MolecularConfiguration*
135  CreateMolecularConfiguration(const G4String& userIdentifier,
136  const G4MoleculeDefinition*,
137  const G4String& label,
138  const G4ElectronOccupancy& eOcc,
139  bool& wasAlreadyCreated);
140 
141  static G4MolecularConfiguration*
142  CreateMolecularConfiguration(const G4String& userIdentifier,
143  const G4MoleculeDefinition*,
144  int charge,
145  const G4String& label,
146  bool& wasAlreadyCreated);
147 
148  static G4MolecularConfiguration*
149  CreateMolecularConfiguration(const G4String& userIdentifier,
150  const G4MoleculeDefinition*,
151  const G4String& label,
152  bool& wasAlreadyCreated);
153 
155  // GET MOL CONF
156  //
157  static G4MolecularConfiguration*
158  GetMolecularConfiguration(const G4MoleculeDefinition*,
159  const G4String& label);
160 
161  static G4MolecularConfiguration*
162  GetMolecularConfiguration(int moleculeID);
163 
164  static G4MolecularConfiguration*
165  GetMolecularConfiguration(const G4String& userID);
166 
167  static int GetNumberOfSpecies();
168 
169  static std::map<G4String, G4MolecularConfiguration*>& GetUserIDTable()
170  {
171  return GetManager()->GetUserIDTable();
172  }
173 
174  // Release memory of the mol conf manager
175  static void DeleteManager();
176 
177  static double DiffCoeffWater(double temperature_K);
178 
179  void AddDiffCoeffParameterization(const G4DiffCoeffParam&);
180 
181  //____________________________________________________________________________
182 
183  const G4MoleculeDefinition* GetDefinition() const;
184 
187  const G4String& GetName() const;
188 
191  const G4String& GetFormatedName() const;
192 
195  G4int GetAtomsNumber() const;
196 
199  G4MolecularConfiguration* ExciteMolecule(G4int) const;
200 
203  G4MolecularConfiguration* IonizeMolecule(G4int) const;
204 
209  G4MolecularConfiguration* AddElectron(G4int orbit, G4int n = 1) const;
210 
213  G4MolecularConfiguration* RemoveElectron(G4int, G4int number = 1) const;
214 
217  G4MolecularConfiguration* MoveOneElectron(G4int /*orbit*/, G4int /*orbit*/) const;
218 
221  G4double GetNbElectrons() const;
222 
225  void PrintState() const;
226 
227  const std::vector<const G4MolecularDissociationChannel*>* GetDissociationChannels() const;
228 
229  G4int GetFakeParticleID() const;
230 
231  inline G4int GetMoleculeID() const;
232 
244  inline void SetDiffusionCoefficient(G4double);
245 
248  inline G4double GetDiffusionCoefficient() const;
249 
250  inline G4double GetDiffusionCoefficient(const G4Material*,
251  double temperature) const;
252 
255  inline void SetDecayTime(G4double);
256 
259  inline G4double GetDecayTime() const;
260 
263  inline void SetVanDerVaalsRadius(G4double);
264  inline G4double GetVanDerVaalsRadius() const;
265 
269  inline const G4ElectronOccupancy* GetElectronOccupancy() const;
270 
273  inline G4int GetCharge() const;
274 
277  inline void SetMass(G4double);
278 
281  inline G4double GetMass() const;
282 
283  /*
284  * Adds a label to the molecular configuration
285  * (Can be used for vibrational states for instance)
286  */
287  inline void SetLabel(const G4String&);
288 
289  /*
290  * Returns the label assigned by the user
291  */
292  inline const G4String& GetLabel() const;
293 
294  inline void Finalize();
295  static void FinalizeAll();
296 
297  inline const G4String& GetUserID() const;
298 
299  static void SetGlobalTemperature(G4double);
300  static G4double GetGlobalTemperature();
301 
302  //___________________________________________________________________________
303  // EXPERIMENTAL
304 
305  static G4MolecularConfiguration* Load(std::istream&);
306 
307  void Serialize(std::ostream&);
308  void Unserialize(std::istream&);
309  //___________________________________________________________________________
310 
311 
312 protected:
313  G4MolecularConfiguration(const G4MoleculeDefinition*,
314  const G4ElectronOccupancy&,
315  const G4String& label = "");
316 
317  G4MolecularConfiguration(const G4MoleculeDefinition*,
318  int charge);
319 
320  G4MolecularConfiguration(const G4MoleculeDefinition*,
321  const G4String& label,
322  int charge);
323 
324  G4MolecularConfiguration(std::istream&);
325 
326  G4MolecularConfiguration(const G4MolecularConfiguration&);
327  G4MolecularConfiguration & operator=(G4MolecularConfiguration &right);
328  ~G4MolecularConfiguration();
329  G4MolecularConfiguration* ChangeConfiguration(const G4ElectronOccupancy& newElectronOccupancy) const;
330  G4MolecularConfiguration* ChangeConfiguration(int charge) const;
331 
332  void CheckElectronOccupancy(const char* line) const;
333  void MakeExceptionIfFinalized();
334  void SetUserID(const G4String& userID);
335 
336  void CreateDefaultDiffCoeffParam();
337  static void ScaleAllDiffusionCoefficientsOnWater(double temperature_K);
338 
339 public:
340  class G4MolecularConfigurationManager
341  {
342  public:
343  G4MolecularConfigurationManager() :
344  fMoleculeCreationMutex()
345  {
346  fLastMoleculeID = -1;
347  }
348  ~G4MolecularConfigurationManager();
349 
350  int GetNumberOfCreatedSpecies()
351  {
352  return fLastMoleculeID+1;
353  }
354 
355  //------------------------------------------------------------------------
356  // CALLED FROM CONSTRUCTORS
357  G4int Insert(const G4MoleculeDefinition* molDef,
358  const G4ElectronOccupancy& eOcc,
359  G4MolecularConfiguration* molConf);
360 
361  G4int Insert(const G4MoleculeDefinition* molDef,
362  int charge,
363  G4MolecularConfiguration* molConf);
364 
365  G4int Insert(const G4MoleculeDefinition* molDef,
366  const G4String& label,
367  G4MolecularConfiguration* molConf);
368 
369  //------------------------------------------------------------------------
370  // CALLED WHEN USER ADD SPECIES
371  void AddUserID(const G4String& name,
372  G4MolecularConfiguration* molecule);
373 
374  void RecordNewlyLabeledConfiguration(G4MolecularConfiguration* molConf);
375 
376  const G4ElectronOccupancy*
377  FindCommonElectronOccupancy(const G4MoleculeDefinition* molDef,
378  const G4ElectronOccupancy& eOcc);
379 
380  G4MolecularConfiguration*
381  GetMolecularConfiguration(const G4MoleculeDefinition* molDef,
382  const G4ElectronOccupancy& eOcc);
383 
384  G4MolecularConfiguration*
385  GetMolecularConfiguration(const G4MoleculeDefinition* molDef,
386  int charge);
387 
388  G4MolecularConfiguration*
389  GetMolecularConfiguration(const G4MoleculeDefinition* molDef,
390  const G4String& label);
391 
392  G4MolecularConfiguration* GetMolecularConfiguration(int moleculeID);
393 
394  G4MolecularConfiguration* GetMolecularConfiguration(const G4String& userID);
395 
396  G4MolecularConfiguration*
397  GetOrCreateMolecularConfiguration(const G4MoleculeDefinition* molDef,
398  const G4ElectronOccupancy& eOcc);
399 
400  G4MolecularConfiguration*
401  GetOrCreateMolecularConfiguration(const G4MoleculeDefinition* molDef,
402  int charge);
403 
404  static G4Mutex fManagerCreationMutex;
405 
406  void RemoveMolecularConfigurationFromTable(G4MolecularConfiguration*);
407 
408  const std::vector<G4MolecularConfiguration*>& GetAllSpecies()
409  {
410  return fMolConfPerID;
411  }
412 
413  std::map<G4String, G4MolecularConfiguration*>& GetUserIDTable()
414  {
415  return fUserIDTable;
416  }
417 
418  private:
419 
420  //__________________________________________________________________________
421  typedef std::map<G4ElectronOccupancy,
422  G4MolecularConfiguration*,
423  comparator> ElectronOccupancyTable;
424  typedef std::map<const G4MoleculeDefinition*,
425  ElectronOccupancyTable > MolElectronConfTable;
426  MolElectronConfTable fElecOccTable;
427 
428  //__________________________________________________________________________
429  typedef std::map<int,
430  G4MolecularConfiguration*> ChargeTable;
431  typedef std::map<const G4MoleculeDefinition*,
432  ChargeTable> MolChargeConfTable;
433  MolChargeConfTable fChargeTable;
434 
435  //__________________________________________________________________________
436  typedef std::map<const G4String,
437  G4MolecularConfiguration*> LabelTable;
438  typedef std::map<const G4MoleculeDefinition*,
439  std::map<const G4String, G4MolecularConfiguration*> > MolLabelConfTable;
440  MolLabelConfTable fLabelTable;
441 
442  //__________________________________________________________________________
443  typedef std::map<G4String, G4MolecularConfiguration*> UserIDTable;
444  UserIDTable fUserIDTable;
445 
446  //__________________________________________________________________________
447  std::vector<G4MolecularConfiguration*> fMolConfPerID;
448  // Indexed by molecule ID
449 
450  //__________________________________________________________________________
451  G4int fLastMoleculeID;
452  G4Mutex fMoleculeCreationMutex;
453  };
454 
455 protected:
456  static G4MolecularConfigurationManager* fgManager;
457  static G4MolecularConfigurationManager* GetManager();
458 
459  const G4MoleculeDefinition* fMoleculeDefinition;
460  const G4ElectronOccupancy* fElectronOccupancy;
461 
462  mutable G4String* fLabel;
463 
464  G4double fDynDiffusionCoefficient;
465  G4double fDynVanDerVaalsRadius;
466  G4double fDynDecayTime;
467  G4double fDynMass;
468  G4int fDynCharge;
469  G4int fMoleculeID;
470  /*mutable*/ G4String fFormatedName;
471  /*mutable*/ G4String fName;
472  G4String fUserIdentifier;
473  G4bool fIsFinalized;
474 
475  G4DiffCoeffParam fDiffParam;
476  static /*G4ThreadLocal*/double fgTemperature;
477 
478  static double ReturnDefaultDiffCoeff(const G4Material*,
479  double,
480  const G4MolecularConfiguration*
481  molConf);
482 };
483 
484 inline const G4MoleculeDefinition* G4MolecularConfiguration::GetDefinition() const
485 {
486  return fMoleculeDefinition;
487 }
488 
489 inline const G4ElectronOccupancy* G4MolecularConfiguration::GetElectronOccupancy() const
490 {
491  return fElectronOccupancy;
492 }
493 
494 inline void G4MolecularConfiguration::SetDiffusionCoefficient(G4double dynDiffusionCoefficient)
495 {
496  MakeExceptionIfFinalized();
497  fDynDiffusionCoefficient = dynDiffusionCoefficient;
498 }
499 
500 inline G4double G4MolecularConfiguration::GetDiffusionCoefficient() const
501 {
502  return fDynDiffusionCoefficient;
503 }
504 
505 inline void G4MolecularConfiguration::SetDecayTime(G4double dynDecayTime)
506 {
507  MakeExceptionIfFinalized();
508  fDynDecayTime = dynDecayTime;
509 }
510 
511 inline G4double G4MolecularConfiguration::GetDecayTime() const
512 {
513  return fDynDecayTime;
514 }
515 
516 inline void G4MolecularConfiguration::SetVanDerVaalsRadius(G4double dynVanDerVaalsRadius)
517 {
518  MakeExceptionIfFinalized();
519  fDynVanDerVaalsRadius = dynVanDerVaalsRadius;
520 }
521 
522 inline G4double G4MolecularConfiguration::GetVanDerVaalsRadius() const
523 {
524  return fDynVanDerVaalsRadius;
525 }
526 
527 inline G4int G4MolecularConfiguration::GetCharge() const
528 {
529  return fDynCharge;
530 }
531 
532 inline void G4MolecularConfiguration::SetMass(G4double aMass)
533 {
534  MakeExceptionIfFinalized();
535  fDynMass = aMass;
536 }
537 
538 inline G4double G4MolecularConfiguration::GetMass() const
539 {
540  return fDynMass;
541 }
542 
543 inline G4int G4MolecularConfiguration::GetMoleculeID() const
544 {
545  return fMoleculeID;
546 }
547 
548 inline void G4MolecularConfiguration::SetLabel(const G4String& label)
549 {
550  assert(fLabel == 0 || *fLabel == "");
551  if(fLabel == 0)
552  {
553  fLabel = new G4String(label);
554  }
555  else
556  {
557  *fLabel = label;
558  }
559  fgManager->RecordNewlyLabeledConfiguration(this);
560 }
561 
562 inline const G4String& G4MolecularConfiguration::GetLabel() const
563 {
564  if(fLabel == 0)
565  fLabel = new G4String();
566 
567  return (*fLabel);
568 }
569 
570 inline void G4MolecularConfiguration::Finalize()
571 {
572  CreateDefaultDiffCoeffParam();
573  fIsFinalized = true;
574 }
575 
576 inline const G4String& G4MolecularConfiguration::GetUserID() const
577 {
578  return fUserIdentifier;
579 }
580 
581 inline void G4MolecularConfiguration::AddDiffCoeffParameterization
582 (const G4DiffCoeffParam& para)
583 {
584  fDiffParam = para;
585 }
586 
587 inline G4double
588 G4MolecularConfiguration::GetDiffusionCoefficient(const G4Material* material,
589  double temperature) const
590 {
591  return fDiffParam(material, temperature, this);
592 }
593 
594 #endif