Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/molecules/management/src/G4Molecule.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/dna/molecules/management/src/G4Molecule.cc (Version 11.3.0) and /processes/electromagnetic/dna/molecules/management/src/G4Molecule.cc (Version 11.2.1)


  1 // *******************************************      1 // ********************************************************************
  2 // * License and Disclaimer                         2 // * License and Disclaimer                                           *
  3 // *                                                3 // *                                                                  *
  4 // * The  Geant4 software  is  copyright of th      4 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  5 // * the Geant4 Collaboration.  It is provided      5 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  6 // * conditions of the Geant4 Software License      6 // * conditions of the Geant4 Software License,  included in the file *
  7 // * LICENSE and available at  http://cern.ch/      7 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  8 // * include a list of copyright holders.           8 // * include a list of copyright holders.                             *
  9 // *                                                9 // *                                                                  *
 10 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 11 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 12 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 13 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 14 // * use.  Please see the license in the file      14 // * use.  Please see the license in the file  LICENSE  and URL above *
 15 // * for the full disclaimer and the limitatio     15 // * for the full disclaimer and the limitation of liability.         *
 16 // *                                               16 // *                                                                  *
 17 // * This  code  implementation is the result      17 // * This  code  implementation is the result of  the  scientific and *
 18 // * technical work of the GEANT4 collaboratio     18 // * technical work of the GEANT4 collaboration.                      *
 19 // * By using,  copying,  modifying or  distri     19 // * By using,  copying,  modifying or  distributing the software (or *
 20 // * any work based  on the software)  you  ag     20 // * any work based  on the software)  you  agree  to acknowledge its *
 21 // * use  in  resulting  scientific  publicati     21 // * use  in  resulting  scientific  publications,  and indicate your *
 22 // * acceptance of all terms of the Geant4 Sof     22 // * acceptance of all terms of the Geant4 Software license.          *
 23 // *******************************************     23 // ********************************************************************
 24 //                                                 24 //
 25 //                                                 25 //
 26 // -------------------------------------------     26 // ---------------------------------------------------------------------
 27 //  GEANT 4 class header file                      27 //  GEANT 4 class header file
 28 //                                                 28 //
 29 //  History: first implementation, based on G4     29 //  History: first implementation, based on G4DynamicParticle
 30 //           New dependency : G4VUserTrackInfo     30 //           New dependency : G4VUserTrackInformation
 31 //                                                 31 //
 32 //      ---------------- G4Molecule  ---------     32 //      ---------------- G4Molecule  ----------------
 33 //      first design&implementation by Alfonso     33 //      first design&implementation by Alfonso Mantero, 7 Apr 2009
 34 //      New developments Alfonso Mantero & Mat     34 //      New developments Alfonso Mantero & Mathieu Karamitros
 35 //      Oct/Nov 2009 Class Name changed to G4M     35 //      Oct/Nov 2009 Class Name changed to G4Molecule
 36 //                   Removed dependency from G     36 //                   Removed dependency from G4DynamicParticle
 37 //                   New constructors :            37 //                   New constructors :
 38 //                    copy constructor             38 //                    copy constructor
 39 //                    direct ionized/excited m     39 //                    direct ionized/excited molecule
 40 //                   New methods :                 40 //                   New methods :
 41 //                    Get : name,atoms' number     41 //                    Get : name,atoms' number,nb electrons,decayChannel
 42 //                    PrintState //To get the      42 //                    PrintState //To get the electronic level and the
 43 //                                 correspondi     43 //                                 corresponding name of the excitation
 44 //                    Kinematic :                  44 //                    Kinematic :
 45 //                    BuildTrack,GetKineticEne     45 //                    BuildTrack,GetKineticEnergy,GetDiffusionVelocity
 46 //                    Change the way dynCharge     46 //                    Change the way dynCharge and eNb is calculated
 47 // -------------------------------------------     47 // ---------------------------------------------------------------------
 48                                                    48 
 49 #include "G4Molecule.hh"                           49 #include "G4Molecule.hh"
 50 #include "G4MolecularConfiguration.hh"             50 #include "G4MolecularConfiguration.hh"
 51 #include "Randomize.hh"                            51 #include "Randomize.hh"
 52 #include "G4PhysicalConstants.hh"                  52 #include "G4PhysicalConstants.hh"
 53 #include "G4SystemOfUnits.hh"                      53 #include "G4SystemOfUnits.hh"
 54 #include "G4Track.hh"                              54 #include "G4Track.hh"
 55 #include "G4VMoleculeCounter.hh"                   55 #include "G4VMoleculeCounter.hh"
 56                                                    56 
 57 using namespace std;                               57 using namespace std;
 58                                                    58 
 59 G4Allocator<G4Molecule>*& aMoleculeAllocator()     59 G4Allocator<G4Molecule>*& aMoleculeAllocator()
 60 {                                                  60 {
 61     G4ThreadLocalStatic G4Allocator<G4Molecule     61     G4ThreadLocalStatic G4Allocator<G4Molecule>* _instance = nullptr;
 62     return _instance;                              62     return _instance;
 63 }                                                  63 }
 64                                                    64 
 65 //____________________________________________     65 //______________________________________________________________________________
 66                                                    66 
 67 template<>                                         67 template<>
 68 G4KDNode<G4Molecule>::~G4KDNode() {                68 G4KDNode<G4Molecule>::~G4KDNode() {
 69     fPoint->SetNode(nullptr);                      69     fPoint->SetNode(nullptr);
 70 }                                                  70 }
 71                                                    71 
 72 //____________________________________________     72 //______________________________________________________________________________
 73                                                    73 
 74 G4Molecule* GetMolecule(const G4Track& track)      74 G4Molecule* GetMolecule(const G4Track& track)
 75 {                                                  75 {
 76     return (G4Molecule*)(GetIT(track));            76     return (G4Molecule*)(GetIT(track));
 77 }                                                  77 }
 78                                                    78 
 79 //____________________________________________     79 //______________________________________________________________________________
 80                                                    80 
 81 G4Molecule* GetMolecule(const G4Track* track)      81 G4Molecule* GetMolecule(const G4Track* track)
 82 {                                                  82 {
 83     return (G4Molecule*)(GetIT(track));            83     return (G4Molecule*)(GetIT(track));
 84 }                                                  84 }
 85                                                    85 
 86 //____________________________________________     86 //______________________________________________________________________________
 87                                                    87 
 88 G4Molecule* G4Molecule::GetMolecule(const G4Tr     88 G4Molecule* G4Molecule::GetMolecule(const G4Track* track)
 89 {                                                  89 {
 90     return (G4Molecule*)(GetIT(track));            90     return (G4Molecule*)(GetIT(track));
 91 }                                                  91 }
 92                                                    92 
 93 //____________________________________________     93 //______________________________________________________________________________
 94                                                    94 
 95 void G4Molecule::Print() const                     95 void G4Molecule::Print() const
 96 {                                                  96 {
 97     G4cout << "The user track information is a     97     G4cout << "The user track information is a molecule" << G4endl;
 98 }                                                  98 }
 99                                                    99 
100 //____________________________________________    100 //______________________________________________________________________________
101                                                   101 
102 G4Molecule::G4Molecule(const G4Molecule& right    102 G4Molecule::G4Molecule(const G4Molecule& right)
103     : G4VUserTrackInformation("G4Molecule")       103     : G4VUserTrackInformation("G4Molecule")
104     , G4IT(right)                                 104     , G4IT(right)
105 {                                                 105 {
106     fpMolecularConfiguration = right.fpMolecul    106     fpMolecularConfiguration = right.fpMolecularConfiguration;
107 }                                                 107 }
108                                                   108 
109 //____________________________________________    109 //______________________________________________________________________________
110                                                   110 
111 G4Molecule& G4Molecule::operator=(const G4Mole    111 G4Molecule& G4Molecule::operator=(const G4Molecule& right)
112 {                                                 112 {
113     if (&right == this) return *this;             113     if (&right == this) return *this;
114     fpMolecularConfiguration = right.fpMolecul    114     fpMolecularConfiguration = right.fpMolecularConfiguration;
115     return *this;                                 115     return *this;
116 }                                                 116 }
117                                                   117 
118 //____________________________________________    118 //______________________________________________________________________________
119                                                   119 
120 G4bool G4Molecule::operator==(const G4Molecule    120 G4bool G4Molecule::operator==(const G4Molecule& right) const
121 {                                                 121 {
122     return fpMolecularConfiguration == right.f    122     return fpMolecularConfiguration == right.fpMolecularConfiguration;
123 }                                                 123 }
124                                                   124 
125 //____________________________________________    125 //______________________________________________________________________________
126                                                   126 
127 G4bool G4Molecule::operator!=(const G4Molecule    127 G4bool G4Molecule::operator!=(const G4Molecule& right) const
128 {                                                 128 {
129     return !(*this == right);                     129     return !(*this == right);
130 }                                                 130 }
131                                                   131 
132 //____________________________________________    132 //______________________________________________________________________________
133 /** The two methods below are the most called     133 /** The two methods below are the most called of the simulation :
134  *  compare molecules in the MoleculeStackMana    134  *  compare molecules in the MoleculeStackManager or in
135  *  the InteractionTable                          135  *  the InteractionTable
136  */                                               136  */
137                                                   137 
138 G4bool G4Molecule::operator<(const G4Molecule&    138 G4bool G4Molecule::operator<(const G4Molecule& right) const
139 {                                                 139 {
140     return fpMolecularConfiguration < right.fp    140     return fpMolecularConfiguration < right.fpMolecularConfiguration;
141 }                                                 141 }
142                                                   142 
143 //____________________________________________    143 //______________________________________________________________________________
144                                                   144 
145 G4Molecule::G4Molecule()                          145 G4Molecule::G4Molecule()
146     : G4VUserTrackInformation("G4Molecule")       146     : G4VUserTrackInformation("G4Molecule")
147 {                                                 147 {
148     fpMolecularConfiguration = nullptr;           148     fpMolecularConfiguration = nullptr;
149 }                                                 149 }
150                                                   150 
151 //____________________________________________    151 //______________________________________________________________________________
152                                                   152 
153 G4Molecule::~G4Molecule()                         153 G4Molecule::~G4Molecule()
154 {                                                 154 {
155     if (fpTrack != nullptr)                       155     if (fpTrack != nullptr)
156     {                                             156     {
157         if (G4VMoleculeCounter::Instance()->In    157         if (G4VMoleculeCounter::Instance()->InUse())
158         {                                         158         {
159             G4VMoleculeCounter::Instance()->      159             G4VMoleculeCounter::Instance()->
160                 RemoveAMoleculeAtTime(fpMolecu    160                 RemoveAMoleculeAtTime(fpMolecularConfiguration,
161                                       fpTrack-    161                                       fpTrack->GetGlobalTime(),
162                                       &(fpTrac    162                                       &(fpTrack->GetPosition()));
163         }                                         163         }
164         fpTrack = nullptr;                        164         fpTrack = nullptr;
165     }                                             165     }
166     fpMolecularConfiguration = nullptr;           166     fpMolecularConfiguration = nullptr;
167 }                                                 167 }
168                                                   168 
169 //____________________________________________    169 //______________________________________________________________________________
170 /** Build a molecule at ground state according    170 /** Build a molecule at ground state according to a given
171  *  G4MoleculeDefinition that can be obtained     171  *  G4MoleculeDefinition that can be obtained from G4GenericMoleculeManager
172  */                                               172  */
173 G4Molecule::G4Molecule(G4MoleculeDefinition* p    173 G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition)
174     : G4VUserTrackInformation("G4Molecule")       174     : G4VUserTrackInformation("G4Molecule")
175 {                                                 175 {
176     fpMolecularConfiguration = G4MolecularConf    176     fpMolecularConfiguration = G4MolecularConfiguration::GetOrCreateMolecularConfiguration(pMoleculeDefinition);
177 }                                                 177 }
178                                                   178 
179 //____________________________________________    179 //______________________________________________________________________________
180                                                   180 
181 G4Molecule::G4Molecule(G4MoleculeDefinition* p    181 G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, int charge)
182 {                                                 182 {
183     fpMolecularConfiguration = G4MolecularConf    183     fpMolecularConfiguration = G4MolecularConfiguration::GetOrCreateMolecularConfiguration(pMoleculeDefinition,
184                                                   184                                                                                            charge);
185 }                                                 185 }
186                                                   186 
187 //____________________________________________    187 //______________________________________________________________________________
188 /** Build a molecule at a specific excitation/    188 /** Build a molecule at a specific excitation/ionisation state according
189  *  to a ground state that can be obtained fro    189  *  to a ground state that can be obtained from G4GenericMoleculeManager.
190  *  Put 0 in the second option if this is a io    190  *  Put 0 in the second option if this is a ionisation.
191  */                                               191  */
192 G4Molecule::G4Molecule(G4MoleculeDefinition* p    192 G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition,
193                        G4int OrbitalToFree,       193                        G4int OrbitalToFree,
194                        G4int OrbitalToFill)       194                        G4int OrbitalToFill)
195    : G4VUserTrackInformation("G4Molecule")        195    : G4VUserTrackInformation("G4Molecule")
196 {                                                 196 {
197     if (pMoleculeDefinition->GetGroundStateEle    197     if (pMoleculeDefinition->GetGroundStateElectronOccupancy() != nullptr)
198     {                                             198     {
199         G4ElectronOccupancy dynElectronOccupan    199         G4ElectronOccupancy dynElectronOccupancy(*pMoleculeDefinition->GetGroundStateElectronOccupancy());
200                                                   200 
201         if (OrbitalToFill != 0)                   201         if (OrbitalToFill != 0)
202         {                                         202         {
203             dynElectronOccupancy.RemoveElectro    203             dynElectronOccupancy.RemoveElectron(OrbitalToFree - 1, 1);
204             dynElectronOccupancy.AddElectron(O    204             dynElectronOccupancy.AddElectron(OrbitalToFill - 1, 1);
205             // dynElectronOccupancy.DumpInfo()    205             // dynElectronOccupancy.DumpInfo(); // DEBUG
206         }                                         206         }
207                                                   207 
208         if (OrbitalToFill == 0)                   208         if (OrbitalToFill == 0)
209         {                                         209         {
210             dynElectronOccupancy.RemoveElectro    210             dynElectronOccupancy.RemoveElectron(OrbitalToFree - 1, 1);
211             // dynElectronOccupancy.DumpInfo()    211             // dynElectronOccupancy.DumpInfo(); // DEBUG
212         }                                         212         }
213                                                   213 
214         fpMolecularConfiguration =                214         fpMolecularConfiguration =
215             G4MolecularConfiguration::GetOrCre    215             G4MolecularConfiguration::GetOrCreateMolecularConfiguration(
216                 pMoleculeDefinition, dynElectr    216                 pMoleculeDefinition, dynElectronOccupancy);
217     }                                             217     }
218     else                                          218     else
219     {                                             219     {
220         fpMolecularConfiguration = nullptr;       220         fpMolecularConfiguration = nullptr;
221         G4Exception(                              221         G4Exception(
222             "G4Molecule::G4Molecule(G4Molecule    222             "G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, "
223             "G4int OrbitalToFree, G4int Orbita    223             "G4int OrbitalToFree, G4int OrbitalToFill)",
224             "G4Molecule_wrong_usage_of_constru    224             "G4Molecule_wrong_usage_of_constructor",
225             FatalErrorInArgument,                 225             FatalErrorInArgument,
226             "If you want to use this construct    226             "If you want to use this constructor, the molecule definition has to be "
227             "first defined with electron occup    227             "first defined with electron occupancies");
228     }                                             228     }
229 }                                                 229 }
230                                                   230 
231 //____________________________________________    231 //______________________________________________________________________________
232 /** Specific builder for water molecules to be    232 /** Specific builder for water molecules to be used in Geant4-DNA,
233  * the last option Excitation is true if the m    233  * the last option Excitation is true if the molecule is excited, is
234  * false is the molecule is ionized.              234  * false is the molecule is ionized.
235  */                                               235  */
236 G4Molecule::G4Molecule(G4MoleculeDefinition* p    236 G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition,
237                        G4int level,               237                        G4int level,
238                        G4bool excitation)         238                        G4bool excitation)
239     : G4VUserTrackInformation("G4Molecule")       239     : G4VUserTrackInformation("G4Molecule")
240 {                                                 240 {
241     if (pMoleculeDefinition->GetGroundStateEle    241     if (pMoleculeDefinition->GetGroundStateElectronOccupancy() != nullptr)
242     {                                             242     {
243         G4ElectronOccupancy dynElectronOccupan    243         G4ElectronOccupancy dynElectronOccupancy(*pMoleculeDefinition->GetGroundStateElectronOccupancy());
244                                                   244 
245         if (excitation)                           245         if (excitation)
246         {                                         246         {
247             dynElectronOccupancy.RemoveElectro    247             dynElectronOccupancy.RemoveElectron(level, 1);
248             dynElectronOccupancy.AddElectron(5    248             dynElectronOccupancy.AddElectron(5, 1);
249             // dynElectronOccupancy.DumpInfo()    249             // dynElectronOccupancy.DumpInfo(); // DEBUG
250         }                                         250         }
251         else                                      251         else
252         {                                         252         {
253             dynElectronOccupancy.RemoveElectro    253             dynElectronOccupancy.RemoveElectron(level, 1);
254             // dynElectronOccupancy.DumpInfo()    254             // dynElectronOccupancy.DumpInfo(); // DEBUG
255         }                                         255         }
256                                                   256 
257         fpMolecularConfiguration = G4Molecular    257         fpMolecularConfiguration = G4MolecularConfiguration::GetOrCreateMolecularConfiguration(pMoleculeDefinition,
258                 dynElectronOccupancy);            258                 dynElectronOccupancy);
259     }                                             259     }
260     else                                          260     else
261     {                                             261     {
262         fpMolecularConfiguration = nullptr;       262         fpMolecularConfiguration = nullptr;
263         G4Exception(                              263         G4Exception(
264             "G4Molecule::G4Molecule(G4Molecule    264             "G4Molecule::G4Molecule(G4MoleculeDefinition* pMoleculeDefinition, "
265             "G4int OrbitalToFree, G4int Orbita    265             "G4int OrbitalToFree, G4int OrbitalToFill)",
266             "G4Molecule_wrong_usage_of_constru    266             "G4Molecule_wrong_usage_of_constructor",
267             FatalErrorInArgument,                 267             FatalErrorInArgument,
268             "If you want to use this construct    268             "If you want to use this constructor, the molecule definition has to be "
269             "first defined with electron occup    269             "first defined with electron occupancies");
270     }                                             270     }
271 }                                                 271 }
272                                                   272 
273 //____________________________________________    273 //______________________________________________________________________________
274                                                   274 
275 G4Molecule::G4Molecule(const G4MolecularConfig    275 G4Molecule::G4Molecule(const G4MolecularConfiguration* pMolecularConfiguration)
276 {                                                 276 {
277     fpMolecularConfiguration = pMolecularConfi    277     fpMolecularConfiguration = pMolecularConfiguration;
278 }                                                 278 }
279                                                   279 
280 //____________________________________________    280 //______________________________________________________________________________
281                                                   281 
282 void G4Molecule::SetElectronOccupancy(const G4    282 void G4Molecule::SetElectronOccupancy(const G4ElectronOccupancy* pElectronOcc)
283 {                                                 283 {
284     fpMolecularConfiguration =                    284     fpMolecularConfiguration = 
285         G4MolecularConfiguration::GetOrCreateM    285         G4MolecularConfiguration::GetOrCreateMolecularConfiguration(fpMolecularConfiguration->GetDefinition(),
286                                                   286                                                                     *pElectronOcc);
287 }                                                 287 }
288                                                   288 
289 //____________________________________________    289 //______________________________________________________________________________
290                                                   290 
291 void G4Molecule::ExciteMolecule(G4int excitati    291 void G4Molecule::ExciteMolecule(G4int excitationLevel)
292 {                                                 292 {
293     fpMolecularConfiguration = fpMolecularConf    293     fpMolecularConfiguration = fpMolecularConfiguration->ExciteMolecule(excitationLevel);
294 }                                                 294 }
295                                                   295 
296 //____________________________________________    296 //______________________________________________________________________________
297                                                   297 
298 void G4Molecule::IonizeMolecule(G4int ionizati    298 void G4Molecule::IonizeMolecule(G4int ionizationLevel)
299 {                                                 299 {
300     fpMolecularConfiguration = fpMolecularConf    300     fpMolecularConfiguration = fpMolecularConfiguration->IonizeMolecule(ionizationLevel);
301 }                                                 301 }
302                                                   302 
303 //____________________________________________    303 //______________________________________________________________________________
304                                                   304 
305 void G4Molecule::AddElectron(G4int orbit, G4in    305 void G4Molecule::AddElectron(G4int orbit, G4int number)
306 {                                                 306 {
307     fpMolecularConfiguration = fpMolecularConf    307     fpMolecularConfiguration = fpMolecularConfiguration->AddElectron(orbit, number);
308 }                                                 308 }
309                                                   309 
310 //____________________________________________    310 //______________________________________________________________________________
311                                                   311 
312 void G4Molecule::RemoveElectron(G4int orbit, G    312 void G4Molecule::RemoveElectron(G4int orbit, G4int number)
313 {                                                 313 {
314     fpMolecularConfiguration =                    314     fpMolecularConfiguration =
315         fpMolecularConfiguration->RemoveElectr    315         fpMolecularConfiguration->RemoveElectron(orbit, number);
316 }                                                 316 }
317                                                   317 
318 //____________________________________________    318 //______________________________________________________________________________
319                                                   319 
320 void G4Molecule::MoveOneElectron(G4int orbitTo    320 void G4Molecule::MoveOneElectron(G4int orbitToFree, G4int orbitToFill)
321 {                                                 321 {
322     fpMolecularConfiguration =                    322     fpMolecularConfiguration =
323         fpMolecularConfiguration->MoveOneElect    323         fpMolecularConfiguration->MoveOneElectron(orbitToFree, orbitToFill);
324 }                                                 324 }
325                                                   325 
326 //____________________________________________    326 //______________________________________________________________________________
327                                                   327 
328 const G4String& G4Molecule::GetName() const       328 const G4String& G4Molecule::GetName() const
329 {                                                 329 {
330     return fpMolecularConfiguration->GetName()    330     return fpMolecularConfiguration->GetName();
331 }                                                 331 }
332                                                   332 
333 //____________________________________________    333 //______________________________________________________________________________
334                                                   334 
335 const G4String& G4Molecule::GetFormatedName()     335 const G4String& G4Molecule::GetFormatedName() const
336 {                                                 336 {
337     return fpMolecularConfiguration->GetFormat    337     return fpMolecularConfiguration->GetFormatedName();
338 }                                                 338 }
339                                                   339 
340 //____________________________________________    340 //______________________________________________________________________________
341                                                   341 
342 G4int G4Molecule::GetAtomsNumber() const          342 G4int G4Molecule::GetAtomsNumber() const
343 {                                                 343 {
344     return fpMolecularConfiguration->GetAtomsN    344     return fpMolecularConfiguration->GetAtomsNumber();
345 }                                                 345 }
346                                                   346 
347 //____________________________________________    347 //______________________________________________________________________________
348                                                   348 
349 G4double G4Molecule::GetNbElectrons() const       349 G4double G4Molecule::GetNbElectrons() const
350 {                                                 350 {
351     return fpMolecularConfiguration->GetNbElec    351     return fpMolecularConfiguration->GetNbElectrons();
352 }                                                 352 }
353                                                   353 
354 //____________________________________________    354 //______________________________________________________________________________
355                                                   355 
356 void G4Molecule::PrintState() const               356 void G4Molecule::PrintState() const
357 {                                                 357 {
358     fpMolecularConfiguration->PrintState();       358     fpMolecularConfiguration->PrintState();
359 }                                                 359 }
360                                                   360 
361 //____________________________________________    361 //______________________________________________________________________________
362                                                   362 
363 G4Track* G4Molecule::BuildTrack(G4double globa    363 G4Track* G4Molecule::BuildTrack(G4double globalTime,
364                                  const G4Three    364                                  const G4ThreeVector& position)
365 {                                                 365 {
366     if (fpTrack != nullptr)                       366     if (fpTrack != nullptr)
367     {                                             367     {
368         G4Exception("G4Molecule::BuildTrack",     368         G4Exception("G4Molecule::BuildTrack", "Molecule001", FatalErrorInArgument,
369                     "A track was already assig    369                     "A track was already assigned to this molecule");
370     }                                             370     }
371                                                   371 
372     // Kinetic Values                             372     // Kinetic Values
373     // Set a random direction to the molecule     373     // Set a random direction to the molecule
374     G4double costheta = (2 * G4UniformRand() -    374     G4double costheta = (2 * G4UniformRand() - 1);
375     G4double theta = acos(costheta);              375     G4double theta = acos(costheta);
376     G4double phi = 2 * pi * G4UniformRand();      376     G4double phi = 2 * pi * G4UniformRand();
377                                                   377 
378     G4double xMomentum = cos(phi) * sin(theta)    378     G4double xMomentum = cos(phi) * sin(theta);
379     G4double yMomentum = sin(theta) * sin(phi)    379     G4double yMomentum = sin(theta) * sin(phi);
380     G4double zMomentum = costheta;                380     G4double zMomentum = costheta;
381                                                   381 
382     G4ThreeVector MomentumDirection(xMomentum,    382     G4ThreeVector MomentumDirection(xMomentum, yMomentum, zMomentum);
383     G4double KineticEnergy = GetKineticEnergy(    383     G4double KineticEnergy = GetKineticEnergy();
384                                                   384 
385     auto  dynamicParticle = new G4DynamicParti    385     auto  dynamicParticle = new G4DynamicParticle(
386         fpMolecularConfiguration->GetDefinitio    386         fpMolecularConfiguration->GetDefinition(), MomentumDirection,
387         KineticEnergy);                           387         KineticEnergy);
388                                                   388 
389     if (G4VMoleculeCounter::Instance()->InUse(    389     if (G4VMoleculeCounter::Instance()->InUse())
390     {                                             390     {
391         G4VMoleculeCounter::Instance()->          391         G4VMoleculeCounter::Instance()->
392             AddAMoleculeAtTime(fpMolecularConf    392             AddAMoleculeAtTime(fpMolecularConfiguration,
393                                globalTime,        393                                globalTime,
394                                &(fpTrack->GetP    394                                &(fpTrack->GetPosition()));
395     }                                             395     }
396                                                   396 
397     //Set the Track                               397     //Set the Track
398     fpTrack = new G4Track(dynamicParticle, glo    398     fpTrack = new G4Track(dynamicParticle, globalTime, position);
399     fpTrack->SetUserInformation(this);            399     fpTrack->SetUserInformation(this);
400                                                   400 
401     return fpTrack;                               401     return fpTrack;
402 }                                                 402 }
403                                                   403 
404 //____________________________________________    404 //______________________________________________________________________________
405                                                   405 
406 G4double G4Molecule::GetKineticEnergy() const     406 G4double G4Molecule::GetKineticEnergy() const
407 {                                                 407 {
408     ////                                          408     ////
409     // Ideal Gaz case                             409     // Ideal Gaz case
410     double v = GetDiffusionVelocity();            410     double v = GetDiffusionVelocity();
411     double E = (fpMolecularConfiguration->GetM    411     double E = (fpMolecularConfiguration->GetMass() / (c_squared)) * (v * v) / 2.;
412     ////                                          412     ////
413     return E;                                     413     return E;
414 }                                                 414 }
415                                                   415 
416 //____________________________________________    416 //______________________________________________________________________________
417                                                   417 
418 G4double G4Molecule::GetDiffusionVelocity() co    418 G4double G4Molecule::GetDiffusionVelocity() const
419 {                                                 419 {
420     double moleculeMass = fpMolecularConfigura    420     double moleculeMass = fpMolecularConfiguration->GetMass() / (c_squared);
421                                                   421 
422     ////                                          422     ////
423     // Different possibilities                    423     // Different possibilities
424     ////                                          424     ////
425     // Ideal Gaz case : Maxwell Boltzmann Dist    425     // Ideal Gaz case : Maxwell Boltzmann Distribution
426     //    double sigma = k_Boltzmann * fgTempe    426     //    double sigma = k_Boltzmann * fgTemperature / mass;
427     //    return G4RandGauss::shoot( 0, sigma     427     //    return G4RandGauss::shoot( 0, sigma );
428     ////                                          428     ////
429     // Ideal Gaz case : mean velocity from equ    429     // Ideal Gaz case : mean velocity from equipartition theorem
430     return sqrt(3 * k_Boltzmann *                 430     return sqrt(3 * k_Boltzmann *
431                 G4MolecularConfiguration::GetG    431                 G4MolecularConfiguration::GetGlobalTemperature() / moleculeMass);
432     ////                                          432     ////
433     // Using this approximation for liquid is     433     // Using this approximation for liquid is wrong
434     // However the brownian process avoid taki    434     // However the brownian process avoid taking
435     // care of energy consideration and plays     435     // care of energy consideration and plays only
436     // with positions                             436     // with positions
437 }                                                 437 }
438                                                   438 
439 //____________________________________________    439 //______________________________________________________________________________
440                                                   440 
441 // added - to be transformed in a "Decay metho    441 // added - to be transformed in a "Decay method"
442 const vector<const G4MolecularDissociationChan    442 const vector<const G4MolecularDissociationChannel*>*
443 G4Molecule::GetDissociationChannels() const       443 G4Molecule::GetDissociationChannels() const
444 {                                                 444 {
445     return fpMolecularConfiguration->GetDissoc    445     return fpMolecularConfiguration->GetDissociationChannels();
446 }                                                 446 }
447                                                   447 
448 //____________________________________________    448 //______________________________________________________________________________
449                                                   449 
450 G4int G4Molecule::GetFakeParticleID() const       450 G4int G4Molecule::GetFakeParticleID() const
451 {                                                 451 {
452     return fpMolecularConfiguration->GetFakePa    452     return fpMolecularConfiguration->GetFakeParticleID();
453 }                                                 453 }
454                                                   454 
455 //____________________________________________    455 //______________________________________________________________________________
456                                                   456 
457 G4int G4Molecule::GetMoleculeID() const           457 G4int G4Molecule::GetMoleculeID() const
458 {                                                 458 {
459     return fpMolecularConfiguration->GetMolecu    459     return fpMolecularConfiguration->GetMoleculeID();
460 }                                                 460 }
461                                                   461 
462 //____________________________________________    462 //______________________________________________________________________________
463                                                   463 
464 G4double G4Molecule::GetDecayTime() const         464 G4double G4Molecule::GetDecayTime() const
465 {                                                 465 {
466     return fpMolecularConfiguration->GetDecayT    466     return fpMolecularConfiguration->GetDecayTime();
467 }                                                 467 }
468                                                   468 
469 //____________________________________________    469 //______________________________________________________________________________
470                                                   470 
471 G4double G4Molecule::GetVanDerVaalsRadius() co    471 G4double G4Molecule::GetVanDerVaalsRadius() const
472 {                                                 472 {
473     return fpMolecularConfiguration->GetVanDer    473     return fpMolecularConfiguration->GetVanDerVaalsRadius();
474 }                                                 474 }
475                                                   475 
476 //____________________________________________    476 //______________________________________________________________________________
477                                                   477 
478 G4int G4Molecule::GetCharge() const               478 G4int G4Molecule::GetCharge() const
479 {                                                 479 {
480     return fpMolecularConfiguration->GetCharge    480     return fpMolecularConfiguration->GetCharge();
481 }                                                 481 }
482                                                   482 
483 //____________________________________________    483 //______________________________________________________________________________
484                                                   484 
485 G4double G4Molecule::GetMass() const              485 G4double G4Molecule::GetMass() const
486 {                                                 486 {
487     return fpMolecularConfiguration->GetMass()    487     return fpMolecularConfiguration->GetMass();
488 }                                                 488 }
489                                                   489 
490 //____________________________________________    490 //______________________________________________________________________________
491                                                   491 
492 const G4ElectronOccupancy* G4Molecule::GetElec    492 const G4ElectronOccupancy* G4Molecule::GetElectronOccupancy() const
493 {                                                 493 {
494     return fpMolecularConfiguration->GetElectr    494     return fpMolecularConfiguration->GetElectronOccupancy();
495 }                                                 495 }
496                                                   496 
497 //____________________________________________    497 //______________________________________________________________________________
498                                                   498 
499 const G4MoleculeDefinition* G4Molecule::GetDef    499 const G4MoleculeDefinition* G4Molecule::GetDefinition() const
500 {                                                 500 {
501     return fpMolecularConfiguration->GetDefini    501     return fpMolecularConfiguration->GetDefinition();
502 }                                                 502 }
503                                                   503 
504 //____________________________________________    504 //______________________________________________________________________________
505                                                   505 
506 G4double G4Molecule::GetDiffusionCoefficient()    506 G4double G4Molecule::GetDiffusionCoefficient() const
507 {                                                 507 {
508     return fpMolecularConfiguration->GetDiffus    508     return fpMolecularConfiguration->GetDiffusionCoefficient();
509 }                                                 509 }
510                                                   510 
511 //____________________________________________    511 //______________________________________________________________________________
512                                                   512 
513 G4double G4Molecule::GetDiffusionCoefficient(c    513 G4double G4Molecule::GetDiffusionCoefficient(const G4Material* pMaterial,
514                                              d    514                                              double temperature) const
515 {                                                 515 {
516     return fpMolecularConfiguration->GetDiffus    516     return fpMolecularConfiguration->GetDiffusionCoefficient(pMaterial,
517                                                   517                                                              temperature);
518 }                                                 518 }
519                                                   519 
520 //____________________________________________    520 //______________________________________________________________________________
521                                                   521 
522 const G4MolecularConfiguration* G4Molecule::Ge    522 const G4MolecularConfiguration* G4Molecule::GetMolecularConfiguration() const
523 {                                                 523 {
524     return fpMolecularConfiguration;              524     return fpMolecularConfiguration;
525 }                                                 525 }
526                                                   526 
527 //____________________________________________    527 //______________________________________________________________________________
528                                                   528 
529 const G4String& G4Molecule::GetLabel() const      529 const G4String& G4Molecule::GetLabel() const
530 {                                                 530 {
531     return fpMolecularConfiguration->GetLabel(    531     return fpMolecularConfiguration->GetLabel();
532 }                                                 532 }
533                                                   533 
534 //____________________________________________    534 //______________________________________________________________________________
535                                                   535 
536 void G4Molecule::ChangeConfigurationToLabel(co    536 void G4Molecule::ChangeConfigurationToLabel(const G4String& label)
537 {                                                 537 {
538     // TODO check fpMolecularConfiguration alr    538     // TODO check fpMolecularConfiguration already exists
539     // and new one as well                        539     // and new one as well
540     // TODO notify for stack change               540     // TODO notify for stack change
541     fpMolecularConfiguration = G4MolecularConf    541     fpMolecularConfiguration = G4MolecularConfiguration::GetMolecularConfiguration(
542         fpMolecularConfiguration->GetDefinitio    542         fpMolecularConfiguration->GetDefinition(), label);
543                                                   543 
544     assert(fpMolecularConfiguration != nullptr    544     assert(fpMolecularConfiguration != nullptr);
545 }                                                 545 }
546                                                   546