| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
>> 26 // $Id: G4MolecularConfiguration.cc 65022 2012-11-12 16:43:12Z gcosmo $
26 // 27 //
27 // Author: Mathieu Karamitros (kara (AT) cenbg 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
28 // 29 //
29 // History: 30 // History:
30 // ----------- 31 // -----------
31 // 10 Oct 2011 M.Karamitros created 32 // 10 Oct 2011 M.Karamitros created
32 // 33 //
33 // ------------------------------------------- 34 // -------------------------------------------------------------------
34 35
35 #include "G4MolecularConfiguration.hh" 36 #include "G4MolecularConfiguration.hh"
36 #include "G4MoleculeDefinition.hh" <<
37 #include "G4UIcommand.hh" 37 #include "G4UIcommand.hh"
38 #include "G4AllocatorList.hh" <<
39 #include "G4AutoLock.hh" <<
40 #include "G4MoleculeTable.hh" <<
41 #include "G4Serialize.hh" <<
42 #include <fstream> <<
43 <<
44 using CLHEP::m2; <<
45 using CLHEP::s; <<
46 using CLHEP::kelvin; <<
47 38
48 using namespace std; 39 using namespace std;
49 40
50 #if defined ( WIN32 ) << 41 //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
51 #define __func__ __FUNCTION__ <<
52 #endif <<
53 <<
54 /*G4ThreadLocal*/G4double G4MolecularConfigura <<
55 // 25°C, used to shoot an energy <<
56 <<
57 //____________________________________________ <<
58 // G4MolecularConfigurationManager 42 // G4MolecularConfigurationManager
59 using MolecularConfigurationManager = G4Molecu << 43 G4MolecularConfiguration::G4MolecularConfigurationManager* G4MolecularConfiguration::fgManager = 0 ;
60 <<
61 MolecularConfigurationManager* G4MolecularConf <<
62 <<
63 G4Mutex MolecularConfigurationManager::fManage <<
64 <<
65 int G4MolecularConfiguration::GetNumberOfSpeci <<
66 { <<
67 return GetManager()->GetNumberOfCreatedSpeci <<
68 } <<
69 <<
70 double G4MolecularConfiguration::ReturnDefault <<
71 double, <<
72 const G4M <<
73 molConf) <<
74 { <<
75 return molConf->fDynDiffusionCoefficient; <<
76 } <<
77 <<
78 G4MolecularConfiguration::G4MolecularConfigura <<
79 <<
80 <<
81 { <<
82 fMoleculeDefinition = moleculeDef; <<
83 <<
84 fLabel = new G4String(label); <<
85 <<
86 fMoleculeID = GetManager()->Insert(moleculeD <<
87 label, <<
88 this); <<
89 fElectronOccupancy = nullptr; <<
90 <<
91 fDynCharge = charge; <<
92 <<
93 fDynMass = fMoleculeDefinition->GetMass(); <<
94 <<
95 fDynDiffusionCoefficient = fMoleculeDefiniti <<
96 fDynVanDerVaalsRadius = fMoleculeDefinition- <<
97 fDynDecayTime = fMoleculeDefinition->GetDeca <<
98 <<
99 fName = fMoleculeDefinition->GetName(); <<
100 fName += "^"; <<
101 fName += G4UIcommand::ConvertToString(fDynCh <<
102 <<
103 fFormatedName = fMoleculeDefinition->GetForm <<
104 fFormatedName += "^"; <<
105 fFormatedName += "{"; <<
106 fFormatedName += G4UIcommand::ConvertToStrin <<
107 fFormatedName += "}"; <<
108 <<
109 fDiffParam = &G4MolecularConfiguration::Retu <<
110 fIsFinalized = false; <<
111 } <<
112 <<
113 void G4MolecularConfiguration::MakeExceptionIf <<
114 { <<
115 if(fIsFinalized) <<
116 { <<
117 G4ExceptionDescription errMsg; <<
118 errMsg << "This molecular configuration " <<
119 << " is already finalized. Therefor <<
120 " properties cannot be changed."; <<
121 G4Exception("G4MolecularConfiguration::Mak <<
122 "CONF_FINALIZED",FatalExceptio <<
123 } <<
124 } <<
125 <<
126 //____________________________________________ <<
127 44
128 G4MolecularConfiguration::G4MolecularConfigura 45 G4MolecularConfiguration::G4MolecularConfigurationManager*
129 G4MolecularConfiguration::GetManager() << 46 G4MolecularConfiguration::GetManager()
130 { 47 {
131 if (fgManager == nullptr) << 48 if(!fgManager)
132 { <<
133 G4AutoLock lock(&MolecularConfigurationMan <<
134 if (fgManager == nullptr) // double check <<
135 { 49 {
136 fgManager = new G4MolecularConfiguration << 50 fgManager = new G4MolecularConfiguration::G4MolecularConfigurationManager;
137 G4MolecularConfigurationManager(); <<
138 } 51 }
139 lock.unlock(); <<
140 } <<
141 52
142 return fgManager; << 53 return fgManager;
143 } 54 }
144 55
145 //____________________________________________ << 56 G4MolecularConfiguration::G4MolecularConfigurationManager::~G4MolecularConfigurationManager()
146 <<
147 G4MolecularConfiguration:: <<
148 G4MolecularConfigurationManager::~G4MolecularC <<
149 { 57 {
150 // G4cout << "Does G4AllocatorList exists= "; << 58 G4MolecularConfigurationManager::MolecularConfigurationTable::iterator it1;
151 // G4cout << (G4AllocatorList::GetAllocatorLi << 59 std::map<G4ElectronOccupancy, G4MolecularConfiguration*, comparator>::iterator it2;
152 // << G4endl; << 60
153 << 61 for(it1 = fTable.begin() ; it1 != fTable.end() ; it1++)
154 G4MolecularConfigurationManager::MolElectron <<
155 G4MolecularConfigurationManager::ElectronOcc <<
156 iterator it2; <<
157 <<
158 for (it1 = fElecOccTable.begin(); it1 != fEl <<
159 { <<
160 for (it2 = it1->second.begin(); it2 != it1 <<
161 { 62 {
162 << 63 for(it2=it1->second.begin(); it2!=it1->second.end(); it2++)
163 << 64 {
164 delete it2->second; << 65 if(it2->second)
165 << 66 {
>> 67 delete it2->second;
>> 68 }
>> 69 }
166 } 70 }
167 } <<
168 fElecOccTable.clear(); <<
169 fgManager = nullptr; <<
170 } <<
171 <<
172 //____________________________________________ <<
173 // G4MolecularConfigurationManager <<
174 G4int G4MolecularConfiguration:: <<
175 G4MolecularConfigurationManager:: <<
176 Insert(const G4MoleculeDefinition* molDef, <<
177 const G4ElectronO <<
178 G4MolecularConfig <<
179 { <<
180 //G4AutoLock lock(&fMoleculeCreationMutex); <<
181 <<
182 ElectronOccupancyTable& table2 = fElecOccTab <<
183 auto it = table2.find(eOcc); <<
184 <<
185 if(it == table2.end()) <<
186 { <<
187 table2[eOcc] = molConf; <<
188 } <<
189 else <<
190 { <<
191 G4ExceptionDescription errMsg; <<
192 errMsg << "The same molecular configuratio <<
193 G4Exception("G4MolecularConfigurationManag <<
194 "SetMolecularConfiguration(con <<
195 "const G4ElectronOccupancy& eO <<
196 "G4MolecularConfiguration* mol <<
197 "", <<
198 FatalException, <<
199 errMsg <<
200 ); <<
201 } <<
202 <<
203 fLastMoleculeID++; <<
204 <<
205 fMolConfPerID.push_back(molConf); <<
206 <<
207 //lock.unlock(); <<
208 return fLastMoleculeID; <<
209 } <<
210 <<
211 //____________________________________________ <<
212 <<
213 const G4ElectronOccupancy* <<
214 G4MolecularConfiguration::G4MolecularConfigura <<
215 FindCommonElectronOccupancy(const G4MoleculeDe <<
216 const G4ElectronOc <<
217 { <<
218 //G4AutoLock lock(&fMoleculeCreationMutex); <<
219 <<
220 auto it1 = fElecOccTable.find(molDef); <<
221 <<
222 if(it1 == fElecOccTable.end()) <<
223 { <<
224 // TODO = handle exception ? <<
225 return nullptr; <<
226 } <<
227 <<
228 ElectronOccupancyTable& table2 = it1->second <<
229 auto it2 = table2.find(eOcc); <<
230 <<
231 //lock.unlock(); <<
232 <<
233 if (it2 == table2.end()) <<
234 { <<
235 // TODO = handle exception ? <<
236 return nullptr; <<
237 } <<
238 <<
239 return &(it2->first); <<
240 } 71 }
241 72
242 //____________________________________________ << 73 //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
243 <<
244 G4MolecularConfiguration* <<
245 G4MolecularConfiguration::G4MolecularConfigura <<
246 GetMolecularConfiguration(const G4MoleculeDefi <<
247 const G4ElectronOccu <<
248 { <<
249 auto it1 = fElecOccTable.find(molDef); <<
250 <<
251 if(it1 == fElecOccTable.end()) return nullpt <<
252 <<
253 ElectronOccupancyTable& table2 = it1->second <<
254 auto it = table2.find(eOcc); <<
255 <<
256 if(it == table2.end()) <<
257 { <<
258 return nullptr; <<
259 } <<
260 <<
261 return it->second; <<
262 } <<
263 <<
264 //____________________________________________ <<
265 <<
266 G4int G4MolecularConfiguration::G4MolecularCon <<
267 Insert(const G4MoleculeDefinition* molDef, <<
268 int charge, <<
269 G4MolecularConfiguration* molConf) <<
270 { <<
271 <<
272 //G4AutoLock lock(&fMoleculeCreationMutex); <<
273 ChargeTable& table2 = fChargeTable[molDef]; <<
274 auto it = table2.find(charge); <<
275 <<
276 if(it == table2.end()) <<
277 { <<
278 table2[charge] = molConf; <<
279 } <<
280 else <<
281 { <<
282 //lock.unlock(); <<
283 G4ExceptionDescription errMsg; <<
284 errMsg << "The same molecular configuratio <<
285 G4Exception("G4MolecularConfigurationManag <<
286 "SetMolecularConfiguration(con <<
287 "int charge," <<
288 "G4MolecularConfiguration* mol <<
289 "", FatalException, errMsg); <<
290 } <<
291 <<
292 fLastMoleculeID++; <<
293 fMolConfPerID.push_back(molConf); <<
294 //lock.unlock(); <<
295 return fLastMoleculeID; <<
296 } <<
297 <<
298 //____________________________________________ <<
299 <<
300 G4MolecularConfiguration* <<
301 G4MolecularConfiguration::G4MolecularConfigura <<
302 GetMolecularConfiguration(const G4MoleculeDefi <<
303 int charge) <<
304 { <<
305 //G4AutoLock lock(&fMoleculeCreationMutex); <<
306 <<
307 auto it1 = fChargeTable.find(molDef); <<
308 <<
309 if(it1 == fChargeTable.end()) return nullptr <<
310 <<
311 ChargeTable& table2 = it1->second; <<
312 auto it = table2.find(charge); <<
313 <<
314 if(it == table2.end()) <<
315 { <<
316 return nullptr; <<
317 } <<
318 <<
319 return it->second; <<
320 <<
321 } <<
322 <<
323 //____________________________________________ <<
324 // Static method in G4MolecularConfiguration 74 // Static method in G4MolecularConfiguration
325 G4MolecularConfiguration* << 75 G4MolecularConfiguration* G4MolecularConfiguration::GetMolecularConfiguration(const G4MoleculeDefinition* molDef)
326 G4MolecularConfiguration:: <<
327 GetOrCreateMolecularConfiguration(const G4Mole <<
328 { 76 {
329 if (molDef->GetGroundStateElectronOccupancy( << 77 const G4ElectronOccupancy& elecOcc = *molDef->GetGroundStateElectronOccupancy();
330 { << 78 if(GetManager()->fTable[molDef][elecOcc])
331 const G4ElectronOccupancy& elecOcc = <<
332 *molDef->GetGroundStateElectronOccupan <<
333 G4MolecularConfiguration* molConf = <<
334 GetManager()->GetMolecularConfiguratio <<
335 <<
336 if (molConf != nullptr) <<
337 { 79 {
338 return molConf; << 80 return GetManager()->fTable[molDef][elecOcc];
>> 81 }
>> 82 else
>> 83 {
>> 84 G4MolecularConfiguration* newConf = new G4MolecularConfiguration(molDef, elecOcc);
>> 85 return newConf ;
339 } 86 }
340 <<
341 auto newConf = <<
342 new G4MolecularConfiguration(molDef, <<
343 elecOcc); <<
344 newConf->SetUserID(molDef->GetName()); <<
345 return newConf; <<
346 } <<
347 <<
348 G4MolecularConfiguration* molConf = <<
349 GetManager()->GetMolecularConfiguration( <<
350 if(molConf != nullptr) <<
351 { <<
352 return molConf; <<
353 } <<
354 <<
355 auto newConf = <<
356 new G4MolecularConfiguration(molDef, mol <<
357 newConf->SetUserID(molDef->GetName()); <<
358 return newConf; <<
359 } <<
360 <<
361 //____________________________________________ <<
362 <<
363 G4MolecularConfiguration* <<
364 G4MolecularConfiguration:: <<
365 GetOrCreateMolecularConfiguration(const G4Mole <<
366 const G4Elec <<
367 { <<
368 return GetManager()->GetOrCreateMolecularCon <<
369 <<
370 // G4MolecularConfiguration* molConf = <<
371 // GetManager()->GetMolecularConfiguratio <<
372 // <<
373 // if (molConf) <<
374 // { <<
375 // return molConf; <<
376 // } <<
377 // else <<
378 // { <<
379 // G4MolecularConfiguration* newConf = <<
380 // new G4MolecularConfiguration(molDef, <<
381 // return newConf; <<
382 // } <<
383 } 87 }
384 88
385 //____________________________________________ << 89 G4MolecularConfiguration* G4MolecularConfiguration::GetMolecularConfiguration(const G4MoleculeDefinition* molDef,
386 << 90 const G4ElectronOccupancy& elecOcc )
387 G4MolecularConfiguration* <<
388 G4MolecularConfiguration:: <<
389 GetOrCreateMolecularConfiguration(const G4Mole <<
390 int charge) <<
391 { 91 {
392 G4MolecularConfiguration* molConf = << 92 if(GetManager()->fTable[molDef][elecOcc])
393 GetManager()->GetMolecularConfiguration( << 93 {
394 << 94 return GetManager()->fTable[molDef][elecOcc];
395 if(molConf != nullptr) << 95 }
396 { << 96 else
397 return molConf; << 97 {
398 } << 98 G4MolecularConfiguration* newConf = new G4MolecularConfiguration(molDef, elecOcc);
399 << 99 return newConf ;
400 auto newConf = << 100 }
401 new G4MolecularConfiguration(molDef, cha <<
402 return newConf; <<
403 } 101 }
404 102
405 //____________________________________________ <<
406 <<
407 void G4MolecularConfiguration::DeleteManager() 103 void G4MolecularConfiguration::DeleteManager()
408 { 104 {
409 G4AutoLock lock(&MolecularConfigurationManag << 105 if(fgManager) delete fgManager;
410 delete fgManager; << 106 fgManager = 0;
411 fgManager = nullptr; <<
412 lock.unlock(); <<
413 } 107 }
414 108
415 //____________________________________________ << 109 //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
416 // G4MolecularConfiguration 110 // G4MolecularConfiguration
417 G4MolecularConfiguration:: << 111 G4MolecularConfiguration::G4MolecularConfiguration(const G4MoleculeDefinition* moleculeDef,
418 G4MolecularConfiguration(const G4MoleculeDefin << 112 const G4ElectronOccupancy& elecOcc)
419 const G4ElectronOccup <<
420 const G4String& label <<
421 { 113 {
422 fMoleculeDefinition = moleculeDef; << 114 fMoleculeDefinition = moleculeDef ;
423 << 115 fgManager->fTable[fMoleculeDefinition][elecOcc] = this;
424 fMoleculeID = GetManager()->Insert(moleculeD << 116 std::map<G4ElectronOccupancy, G4MolecularConfiguration*, comparator>::iterator it ;
425 elecOcc, << 117 it = fgManager->fTable[moleculeDef].find(elecOcc);
426 this); << 118 fElectronOccupancy = &(it->first);
427 fElectronOccupancy = GetManager()->FindCommo << 119
428 << 120 fDynCharge = fMoleculeDefinition->GetNbElectrons()-fElectronOccupancy->GetTotalOccupancy();
429 << 121 fDynMass = fMoleculeDefinition->GetMass() ;
430 /* << 122
431 fgManager->fTable[fMoleculeDefinition][elec << 123 fDynDiffusionCoefficient = fMoleculeDefinition->GetDiffusionCoefficient() ;
432 std::map<G4ElectronOccupancy, G4MolecularCo << 124 fDynVanDerVaalsRadius = fMoleculeDefinition->GetVanDerVaalsRadius() ;
433 it = fgManager->fTable[moleculeDef].find(el << 125 fDynDecayTime = fMoleculeDefinition->GetDecayTime() ;
434 fElectronOccupancy = &(it->first); <<
435 */ <<
436 <<
437 fDynCharge = fMoleculeDefinition->GetNbElect <<
438 - fElectronOccupancy->GetTotalOccupancy( <<
439 + moleculeDef->GetCharge(); <<
440 fDynMass = fMoleculeDefinition->GetMass(); <<
441 <<
442 fDynDiffusionCoefficient = fMoleculeDefiniti <<
443 fDynVanDerVaalsRadius = fMoleculeDefinition- <<
444 fDynDecayTime = fMoleculeDefinition->GetDeca <<
445 <<
446 fName = fMoleculeDefinition->GetName(); <<
447 fName += "^"; <<
448 fName += G4UIcommand::ConvertToString(fDynCh <<
449 <<
450 fFormatedName = fMoleculeDefinition->GetForm <<
451 fFormatedName += "^"; <<
452 fFormatedName += "{"; <<
453 fFormatedName += G4UIcommand::ConvertToStrin <<
454 fFormatedName += "}"; <<
455 <<
456 fLabel = nullptr; // let it here <<
457 <<
458 if(!label.empty()) <<
459 { <<
460 SetLabel(label); <<
461 } <<
462 <<
463 fDiffParam = &G4MolecularConfiguration::Retu <<
464 <<
465 fIsFinalized = false; <<
466 } 126 }
467 127
468 //____________________________________________ <<
469 <<
470 G4MolecularConfiguration:: <<
471 G4MolecularConfiguration(const G4MoleculeDefin <<
472 int charge) <<
473 { <<
474 fMoleculeDefinition = moleculeDef; <<
475 <<
476 fMoleculeID = GetManager()->Insert(moleculeD <<
477 charge, <<
478 this); <<
479 fElectronOccupancy = nullptr; <<
480 <<
481 fDynCharge = charge; <<
482 fDynMass = fMoleculeDefinition->GetMass(); <<
483 <<
484 fDynDiffusionCoefficient = fMoleculeDefiniti <<
485 fDynVanDerVaalsRadius = fMoleculeDefinition- <<
486 fDynDecayTime = fMoleculeDefinition->GetDeca <<
487 <<
488 fName = fMoleculeDefinition->GetName(); <<
489 fName += "^"; <<
490 fName += G4UIcommand::ConvertToString(fDynCh <<
491 <<
492 fFormatedName = fMoleculeDefinition->GetForm <<
493 fFormatedName += "^"; <<
494 fFormatedName += "{"; <<
495 fFormatedName += G4UIcommand::ConvertToStrin <<
496 fFormatedName += "}"; <<
497 <<
498 fLabel = nullptr; <<
499 <<
500 fDiffParam = &G4MolecularConfiguration::Retu <<
501 <<
502 fIsFinalized = false; <<
503 } <<
504 <<
505 //____________________________________________ <<
506 <<
507 G4MolecularConfiguration::~G4MolecularConfigur 128 G4MolecularConfiguration::~G4MolecularConfiguration()
508 { 129 {
509 if (fgManager != nullptr) fgManager->RemoveM << 130 if(fElectronOccupancy)
510 << 131 {
511 // if (G4AllocatorList::GetAllocatorListIfExi << 132 delete fElectronOccupancy;
512 // { << 133 fElectronOccupancy = 0;
513 // if (fElectronOccupancy) << 134 }
514 // { <<
515 // delete fElectronOccupancy; <<
516 // fElectronOccupancy = 0; <<
517 // } <<
518 // } <<
519 } <<
520 <<
521 //____________________________________________ <<
522 <<
523 G4MolecularConfiguration* <<
524 G4MolecularConfiguration:: <<
525 ChangeConfiguration(const G4ElectronOccupancy& <<
526 { <<
527 G4MolecularConfiguration* output = <<
528 GetManager()->GetMolecularConfiguration( <<
529 <<
530 <<
531 if (output == nullptr) <<
532 { <<
533 output = new G4MolecularConfiguration(fMol <<
534 newE <<
535 } <<
536 return output; <<
537 } 135 }
538 136
539 //____________________________________________ << 137 G4MolecularConfiguration* G4MolecularConfiguration::ChangeConfiguration(const G4ElectronOccupancy& newElectronOccupancy)
540 <<
541 G4MolecularConfiguration* <<
542 G4MolecularConfiguration::ChangeConfiguration( <<
543 { 138 {
544 G4MolecularConfiguration* output = << 139 G4MolecularConfiguration* output = fgManager->fTable[fMoleculeDefinition][newElectronOccupancy] ;
545 GetManager()->GetMolecularConfiguration( << 140 if(! output)
546 << 141 {
547 if (output == nullptr) << 142 output = new G4MolecularConfiguration(fMoleculeDefinition, newElectronOccupancy);
548 { << 143 }
549 output = new G4MolecularConfiguration(fMol << 144 return output ;
550 } <<
551 return output; <<
552 } 145 }
553 146
554 //____________________________________________ << 147 G4MolecularConfiguration& G4MolecularConfiguration::operator=(G4MolecularConfiguration& right)
555 <<
556 G4MolecularConfiguration& <<
557 G4MolecularConfiguration::operator=(G4Molecula <<
558 { 148 {
559 // if (&right == this) return *this; << 149 if (&right==this) return *this;
560 return *this; << 150 return *this;
561 } 151 }
562 152
563 //____________________________________________ <<
564 153
565 /** Method used in Geant4-DNA to excite water 154 /** Method used in Geant4-DNA to excite water molecules
566 */ 155 */
567 G4MolecularConfiguration* << 156 G4MolecularConfiguration* G4MolecularConfiguration::ExciteMolecule(G4int ExcitedLevel)
568 G4MolecularConfiguration::ExciteMolecule(G4int <<
569 { 157 {
570 // MakeExceptionIfFinalized(); << 158 G4ElectronOccupancy newElectronOccupancy (*fElectronOccupancy);
571 CheckElectronOccupancy(__func__); <<
572 G4ElectronOccupancy newElectronOccupancy(*fE <<
573 159
574 newElectronOccupancy.RemoveElectron(ExcitedL << 160 newElectronOccupancy.RemoveElectron(ExcitedLevel,1);
575 newElectronOccupancy.AddElectron(5, 1); << 161 newElectronOccupancy.AddElectron(5,1);
576 162
577 return ChangeConfiguration(newElectronOccupa << 163 return ChangeConfiguration(newElectronOccupancy);
578 } 164 }
579 165
580 //____________________________________________ <<
581 <<
582 /** Method used in Geant4-DNA to ionize water 166 /** Method used in Geant4-DNA to ionize water molecules
583 */ 167 */
584 G4MolecularConfiguration* << 168 G4MolecularConfiguration* G4MolecularConfiguration::IonizeMolecule(G4int IonizedLevel)
585 G4MolecularConfiguration::IonizeMolecule(G4int <<
586 { <<
587 // MakeExceptionIfFinalized(); <<
588 CheckElectronOccupancy(__func__); <<
589 G4ElectronOccupancy newElectronOccupancy(*fE <<
590 <<
591 if (newElectronOccupancy.GetOccupancy(Ionize <<
592 { <<
593 newElectronOccupancy.RemoveElectron(Ionize <<
594 } <<
595 else <<
596 { <<
597 G4String errMsg = "There is no electron on <<
598 + G4UIcommand::ConvertToString(Ionized <<
599 + " you want to free. The molecule's n <<
600 + GetName(); <<
601 G4Exception("G4MolecularConfiguration::Ion <<
602 "", <<
603 FatalErrorInArgument, <<
604 errMsg); <<
605 PrintState(); <<
606 } <<
607 <<
608 // DEBUG <<
609 // PrintState(); <<
610 <<
611 return ChangeConfiguration(newElectronOccupa <<
612 } <<
613 <<
614 //____________________________________________ <<
615 <<
616 G4MolecularConfiguration* G4MolecularConfigura <<
617 <<
618 { <<
619 // MakeExceptionIfFinalized(); <<
620 CheckElectronOccupancy(__func__); <<
621 G4ElectronOccupancy newElectronOccupancy(*fE <<
622 newElectronOccupancy.AddElectron(orbit, numb <<
623 return ChangeConfiguration(newElectronOccupa <<
624 } <<
625 <<
626 //____________________________________________ <<
627 <<
628 G4MolecularConfiguration* <<
629 G4MolecularConfiguration::RemoveElectron(G4int <<
630 G4int <<
631 { 169 {
632 // MakeExceptionIfFinalized(); << 170 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
633 CheckElectronOccupancy(__func__); <<
634 G4ElectronOccupancy newElectronOccupancy(*fE <<
635 <<
636 if (newElectronOccupancy.GetOccupancy(orbit) <<
637 { <<
638 newElectronOccupancy.RemoveElectron(orbit, <<
639 } <<
640 else <<
641 { <<
642 G4String errMsg = "There is already no ele <<
643 + G4UIcommand::ConvertToString(orbit) <<
644 + " you want to free. The molecule's n <<
645 G4Exception("G4MolecularConfiguration::Rem <<
646 "", <<
647 JustWarning, <<
648 errMsg); <<
649 PrintState(); <<
650 } <<
651 <<
652 return ChangeConfiguration(newElectronOccupa <<
653 } <<
654 <<
655 //____________________________________________ <<
656 171
657 G4MolecularConfiguration* << 172 if(newElectronOccupancy.GetOccupancy(IonizedLevel) != 0)
658 G4MolecularConfiguration::MoveOneElectron(G4in <<
659 G4in <<
660 { <<
661 // MakeExceptionIfFinalized(); <<
662 CheckElectronOccupancy(__func__); <<
663 G4ElectronOccupancy newElectronOccupancy(*fE <<
664 <<
665 if (newElectronOccupancy.GetOccupancy(orbitT <<
666 { <<
667 newElectronOccupancy.RemoveElectron(orbitT <<
668 newElectronOccupancy.AddElectron(orbitToFi <<
669 } <<
670 else <<
671 { <<
672 G4String errMsg = "There is no electron on <<
673 + G4UIcommand::ConvertToString(orbitTo <<
674 + " you want to free. The molecule's n <<
675 G4Exception("G4MolecularConfiguration::Mov <<
676 "", <<
677 FatalErrorInArgument, <<
678 errMsg); <<
679 PrintState(); <<
680 } <<
681 <<
682 return ChangeConfiguration(newElectronOccupa <<
683 } <<
684 <<
685 //____________________________________________ <<
686 <<
687 const G4String& G4MolecularConfiguration::GetN <<
688 { <<
689 return fName; <<
690 } <<
691 <<
692 //____________________________________________ <<
693 <<
694 const G4String& G4MolecularConfiguration::GetF <<
695 { <<
696 return fFormatedName; <<
697 } <<
698 <<
699 //____________________________________________ <<
700 <<
701 G4int G4MolecularConfiguration::GetAtomsNumber <<
702 { <<
703 return fMoleculeDefinition->GetAtomsNumber() <<
704 } <<
705 <<
706 //____________________________________________ <<
707 <<
708 G4double G4MolecularConfiguration::GetNbElectr <<
709 { <<
710 CheckElectronOccupancy(__func__); <<
711 return fElectronOccupancy->GetTotalOccupancy <<
712 } <<
713 <<
714 //____________________________________________ <<
715 <<
716 void G4MolecularConfiguration::PrintState() co <<
717 { <<
718 G4cout << "-------------- Start Printing Sta <<
719 << " ---------------" << G4endl; <<
720 <<
721 if (fElectronOccupancy != nullptr) <<
722 { <<
723 G4cout << "--------------Print electronic <<
724 << "---------------" << G4endl; <<
725 fElectronOccupancy->DumpInfo(); <<
726 if(fElectronOccupancy==fMoleculeDefinition <<
727 { 173 {
728 G4cout<<"At ground state"<<G4endl; << 174 newElectronOccupancy.RemoveElectron(IonizedLevel,1);
>> 175 }
>> 176 else
>> 177 {
>> 178 G4String errMsg = "There is no electron on the orbit " + G4UIcommand::ConvertToString(IonizedLevel) +
>> 179 " you want to free. The molecule's name you want to ionized is "+ GetName();
>> 180 G4Exception("G4Molecule::IonizeMolecule","",FatalErrorInArgument, errMsg);
>> 181 PrintState();
729 } 182 }
730 } <<
731 else <<
732 { <<
733 G4cout << "--- No electron occupancy set u <<
734 } <<
735 <<
736 G4cout << "Charge :" <<
737 << fDynCharge <<
738 << G4endl; <<
739 <<
740 if(fLabel != nullptr) <<
741 { <<
742 G4cout << "Label :" <<
743 << GetLabel() <<
744 << G4endl; <<
745 } <<
746 G4cout << "-------------- End Of State " << <<
747 << " -----------------------" << G4e <<
748 } <<
749 <<
750 //____________________________________________ <<
751 <<
752 // added - to be transformed in a "Decay metho <<
753 const vector<const G4MolecularDissociationChan <<
754 G4MolecularConfiguration::GetDissociationCha <<
755 { <<
756 // if (fElectronOccupancy == 0) return 0; <<
757 return fMoleculeDefinition->GetDecayChannels <<
758 } <<
759 <<
760 //____________________________________________ <<
761 <<
762 G4int G4MolecularConfiguration::GetFakeParticl <<
763 { <<
764 if(fMoleculeDefinition != nullptr) return fM <<
765 G4Exception("G4MolecularConfiguration::GetMo <<
766 "", <<
767 FatalErrorInArgument, <<
768 "You should first enter a m <<
769 <<
770 return INT_MAX; <<
771 } <<
772 <<
773 //____________________________________________ <<
774 <<
775 const char* removePath(const char* path) <<
776 { <<
777 const char* pDelimeter = strrchr(path, '\\') <<
778 if (pDelimeter != nullptr) path = pDelimeter <<
779 <<
780 pDelimeter = strrchr(path, '/'); <<
781 if (pDelimeter != nullptr) path = pDelimeter <<
782 <<
783 return path; <<
784 } <<
785 <<
786 //____________________________________________ <<
787 <<
788 void G4MolecularConfiguration::CheckElectronOc <<
789 { <<
790 if (fElectronOccupancy == nullptr) <<
791 { <<
792 G4String functionName(function); <<
793 G4ExceptionDescription description; <<
794 description <<
795 << "No G4ElectronOccupancy was defined <<
796 << fMoleculeDefinition->GetName() <<
797 << ". The definition was probably defi <<
798 "rather than electron state."; <<
799 <<
800 G4Exception(functionName, "", FatalErrorIn <<
801 } <<
802 } <<
803 <<
804 //____________________________________________ <<
805 <<
806 void G4MolecularConfiguration::G4MolecularConf <<
807 RecordNewlyLabeledConfiguration(G4MolecularCon <<
808 { <<
809 //G4AutoLock lock(&fMoleculeCreationMutex); <<
810 <<
811 LabelTable& tmpMap = fLabelTable[molConf->fM <<
812 <<
813 auto it = tmpMap.find(*molConf->fLabel); <<
814 <<
815 if(it == tmpMap.end()) <<
816 { <<
817 tmpMap[*(molConf->fLabel)] = molConf; <<
818 } <<
819 else <<
820 { <<
821 G4ExceptionDescription errMsg; <<
822 errMsg << "The same molecular configuratio <<
823 G4Exception("G4MolecularConfigurationManag <<
824 "SetMolecularConfiguration(con <<
825 "const G4String& label," <<
826 "G4MolecularConfiguration* mol <<
827 "", FatalException, errMsg); <<
828 } <<
829 <<
830 //lock.unlock(); <<
831 } <<
832 <<
833 void G4MolecularConfiguration::G4MolecularConf <<
834 <<
835 { <<
836 auto it = fUserIDTable.find(userID); <<
837 <<
838 if(it == fUserIDTable.end()) <<
839 { <<
840 fUserIDTable[userID] = molecule; <<
841 } <<
842 else if(molecule != it->second) <<
843 { <<
844 // TODO improve exception <<
845 // exception <<
846 G4ExceptionDescription description; <<
847 description << "The user identifier " << u <<
848 << " was already given in anot <<
849 << G4endl; <<
850 G4Exception("G4MolecularConfiguration::G4Mol <<
851 "CONF_ALREADY_RECORDED", <<
852 FatalException, <<
853 description); <<
854 } <<
855 } <<
856 <<
857 //____________________________________________ <<
858 <<
859 void G4MolecularConfiguration::G4MolecularConf <<
860 RemoveMolecularConfigurationFromTable(G4Molecu <<
861 { <<
862 auto it1 = <<
863 fElecOccTable.find(configuration->GetDef <<
864 auto end = fElecOccTable.end(); <<
865 <<
866 if (it1 == end) return; <<
867 <<
868 auto it2 = <<
869 it1->second.find(*configuration->GetElec <<
870 <<
871 if (it2 == it1->second.end()) return; <<
872 <<
873 it2->second = 0; <<
874 // it1->second.erase(it2); <<
875 <<
876 configuration->fElectronOccupancy = nullptr; <<
877 } <<
878 <<
879 //____________________________________________ <<
880 <<
881 G4MolecularConfiguration* <<
882 G4MolecularConfiguration::G4MolecularConfigura <<
883 GetMolecularConfiguration(const G4MoleculeDefi <<
884 const G4String& labe <<
885 { <<
886 //G4AutoLock lock(&fMoleculeCreationMutex); <<
887 <<
888 auto it1 = fLabelTable.find(molDef); <<
889 <<
890 if(it1 == fLabelTable.end()) return nullptr; <<
891 <<
892 LabelTable& table2 = it1->second; <<
893 <<
894 auto it2 = table2.find(label); <<
895 <<
896 //lock.unlock(); <<
897 <<
898 if(it2 == table2.end()) return nullptr; <<
899 return it2->second; <<
900 } <<
901 <<
902 //____________________________________________ <<
903 <<
904 G4MolecularConfiguration* <<
905 G4MolecularConfiguration::G4MolecularConfigura <<
906 GetMolecularConfiguration(int moleculeID) <<
907 { <<
908 if(moleculeID > (int) fMolConfPerID.size() | <<
909 moleculeID < 0) return nullptr; <<
910 <<
911 return fMolConfPerID[moleculeID]; <<
912 } <<
913 <<
914 //____________________________________________ <<
915 <<
916 G4int <<
917 G4MolecularConfiguration::G4MolecularConfigura <<
918 Insert(const G4MoleculeDefinition* molDef, <<
919 const G4String& l <<
920 G4MolecularConfig <<
921 { <<
922 G4AutoLock lock(&fMoleculeCreationMutex); <<
923 LabelTable& tmpMap = fLabelTable[molDef]; <<
924 auto it = tmpMap.find(label); <<
925 <<
926 if(it == tmpMap.end()) <<
927 { <<
928 fLastMoleculeID++; <<
929 tmpMap[label] = molConf; <<
930 lock.unlock(); <<
931 } <<
932 else <<
933 { <<
934 lock.unlock(); <<
935 G4ExceptionDescription errMsg; <<
936 errMsg << "The same molecular configuratio <<
937 G4Exception("G4MolecularConfigurationManag <<
938 "SetMolecularConfiguration(con <<
939 "const G4String& label," <<
940 "G4MolecularConfiguration* mol <<
941 "", FatalException, errMsg); <<
942 } <<
943 183
944 fMolConfPerID.push_back(molConf); << 184 // PrintState();
945 185
946 return fLastMoleculeID; << 186 return ChangeConfiguration(newElectronOccupancy);
947 } 187 }
948 188
949 //____________________________________________ << 189 G4MolecularConfiguration* G4MolecularConfiguration::AddElectron(G4int orbit, G4int number)
950 <<
951 G4MolecularConfiguration* <<
952 G4MolecularConfiguration::GetMolecularConfigur <<
953 <<
954 { 190 {
955 return GetManager()->GetMolecularConfigurati << 191 G4ElectronOccupancy newElectronOccupancy(*fElectronOccupancy);
>> 192 newElectronOccupancy.AddElectron(orbit, number);
>> 193 return ChangeConfiguration(newElectronOccupancy);
956 } 194 }
957 195
958 //____________________________________________ << 196 G4MolecularConfiguration* G4MolecularConfiguration::RemoveElectron(G4int orbit,G4int number)
959 <<
960 G4MolecularConfiguration* <<
961 G4MolecularConfiguration::GetMolecularConfigur <<
962 { 197 {
963 return GetManager()->GetMolecularConfigurati << 198 G4ElectronOccupancy newElectronOccupancy (*fElectronOccupancy);
964 } <<
965 <<
966 //____________________________________________ <<
967 199
968 G4MolecularConfiguration* << 200 if(newElectronOccupancy.GetOccupancy(orbit) != 0)
969 G4MolecularConfiguration::CreateMolecularConfi <<
970 <<
971 <<
972 <<
973 <<
974 { <<
975 wasAlreadyCreated = false; <<
976 G4MolecularConfiguration* molConf = <<
977 GetManager()->GetMolecularConfiguration( <<
978 <<
979 if (molConf != nullptr) <<
980 { <<
981 if(molConf->fLabel == nullptr) <<
982 { 201 {
983 molConf->SetLabel(label); << 202 newElectronOccupancy.RemoveElectron(orbit, number );
984 G4ExceptionDescription wMsg ; <<
985 wMsg << "The molecular configuration for <<
986 << molDef->GetName() <<
987 << " with charge " << charge << " <<
988 "but with NO label"; <<
989 G4Exception("G4MolecularConfiguration::C <<
990 "DOUBLE_CREATION", <<
991 JustWarning, <<
992 wMsg); <<
993 } 203 }
994 else if(molConf->fLabel->empty() ) << 204 else
995 { 205 {
996 molConf->SetLabel(label); << 206 G4String errMsg = "There is already no electron into the orbit " + G4UIcommand::ConvertToString(orbit) +
>> 207 " you want to free. The molecule's name is "+ GetName();
>> 208 G4Exception("G4Molecule::RemoveElectron","",JustWarning, errMsg);
>> 209 PrintState();
997 } 210 }
998 else if(*(molConf->fLabel) != label) <<
999 { <<
1000 G4ExceptionDescription errMsg ; <<
1001 errMsg << "The molecular configuration <<
1002 << molDef->GetName() <<
1003 << " with charge " << charge << <<
1004 "but with a different label <<
1005 << molConf->GetLabel(); <<
1006 G4Exception("G4MolecularConfiguration:: <<
1007 "DOUBLE_CREATION", <<
1008 FatalErrorInArgument, <<
1009 errMsg); <<
1010 // KILL APP <<
1011 } <<
1012 <<
1013 if(molConf->fUserIdentifier.empty()) <<
1014 { <<
1015 molConf->fUserIdentifier = userIdentifi <<
1016 <<
1017 G4ExceptionDescription wMsg ; <<
1018 wMsg << "The molecular configuration fo <<
1019 << molDef->GetName() <<
1020 << " with label " << label << " <<
1021 G4Exception("G4MolecularConfiguration:: <<
1022 "DOUBLE_CREATION", <<
1023 JustWarning, <<
1024 wMsg); <<
1025 } <<
1026 else if(molConf->fUserIdentifier != userI <<
1027 { <<
1028 G4ExceptionDescription errMsg ; <<
1029 errMsg << "The molecular configuration <<
1030 << molDef->GetName() <<
1031 << " with label " << label << " <<
1032 "BUT with a different user I <<
1033 << molConf->fUserIdentifier; <<
1034 G4Exception("G4MolecularConfiguration:: <<
1035 "DOUBLE_CREATION", <<
1036 FatalErrorInArgument, <<
1037 errMsg); <<
1038 // KILL APP <<
1039 } <<
1040 <<
1041 wasAlreadyCreated = true; <<
1042 return molConf; <<
1043 } <<
1044 <<
1045 auto newConf = <<
1046 new G4MolecularConfiguration(molDef, la <<
1047 newConf->fUserIdentifier = userIdentifier; <<
1048 <<
1049 GetManager()->AddUserID(userIdentifier, new <<
1050 <<
1051 // G4MoleculeTable::Instance()->RecordMole <<
1052 // <<
1053 return newConf; <<
1054 } <<
1055 <<
1056 //___________________________________________ <<
1057 211
1058 G4MolecularConfiguration* << 212 return ChangeConfiguration(newElectronOccupancy);
1059 G4MolecularConfiguration:: <<
1060 CreateMolecularConfiguration(const G4String& <<
1061 const G4Molecule <<
1062 bool& wasAlready <<
1063 { <<
1064 wasAlreadyCreated = false; <<
1065 G4MolecularConfiguration* preRegisteredMolC <<
1066 GetManager()->GetMolecularConfiguration <<
1067 <<
1068 if(preRegisteredMolConf != nullptr) <<
1069 { <<
1070 if(preRegisteredMolConf->GetDefinition() <<
1071 { <<
1072 wasAlreadyCreated = true; <<
1073 return preRegisteredMolConf; <<
1074 } <<
1075 } <<
1076 <<
1077 if(molDef->GetGroundStateElectronOccupancy( <<
1078 { <<
1079 const G4ElectronOccupancy& elecOcc = *mol <<
1080 ->GetGroundStateElectronOccupancy(); <<
1081 G4MolecularConfiguration* molConf = <<
1082 GetManager()->GetMolecularConfigurati <<
1083 <<
1084 if(molConf != nullptr) <<
1085 { <<
1086 if(molConf->fUserIdentifier.empty()) <<
1087 { <<
1088 molConf->fUserIdentifier = userIdenti <<
1089 } <<
1090 else if(molConf->fUserIdentifier != use <<
1091 { <<
1092 G4ExceptionDescription errMsg; <<
1093 errMsg << "A molecular configuration <<
1094 << molDef->GetName() << " has <<
1095 "and recorded with a different <<
1096 << molConf->fUserIdentifier; <<
1097 G4Exception("G4MolecularConfiguration <<
1098 "DOUBLE_CREATION", <<
1099 FatalErrorInArgument, <<
1100 errMsg); <<
1101 } <<
1102 // TODO exception <<
1103 G4ExceptionDescription errMsg; <<
1104 errMsg << "A molecular configuration fo <<
1105 << molDef->GetName() << " has al <<
1106 G4Exception("G4MolecularConfiguration:: <<
1107 "DOUBLE_CREATION", <<
1108 JustWarning, <<
1109 errMsg); <<
1110 wasAlreadyCreated = true; <<
1111 return molConf; <<
1112 } <<
1113 <<
1114 // G4cout << "Create molConf for " << mol <<
1115 auto newConf = new G4MolecularConfigurat <<
1116 <<
1117 newConf->fUserIdentifier = userIdentifier <<
1118 <<
1119 GetManager()->AddUserID(userIdentifier, n <<
1120 <<
1121 // G4MoleculeTable::Instance()->RecordMo <<
1122 // <<
1123 return newConf; <<
1124 } <<
1125 <<
1126 return CreateMolecularConfiguration(userIde <<
1127 molDef, <<
1128 molDef- <<
1129 molDef- <<
1130 wasAlre <<
1131 } 213 }
1132 214
1133 //___________________________________________ << 215 G4MolecularConfiguration* G4MolecularConfiguration::MoveOneElectron(G4int orbitToFree,G4int orbitToFill)
1134 <<
1135 G4MolecularConfiguration* <<
1136 G4MolecularConfiguration:: <<
1137 CreateMolecularConfiguration(const G4String& <<
1138 const G4Molecule <<
1139 const G4String& <<
1140 bool& wasAlready <<
1141 { 216 {
1142 assert(label != ""); << 217 G4ElectronOccupancy newElectronOccupancy (*fElectronOccupancy);
1143 wasAlreadyCreated = false; <<
1144 218
1145 G4MolecularConfiguration* molConf = << 219 if(newElectronOccupancy . GetOccupancy(orbitToFree)>=1)
1146 GetManager()->GetMolecularConfiguration <<
1147 if(molConf != nullptr) <<
1148 { <<
1149 if((molConf->fLabel != nullptr) <<
1150 && *molConf->fLabel == label) <<
1151 { <<
1152 wasAlreadyCreated = true; <<
1153 return molConf; <<
1154 } <<
1155 if(molConf->fLabel == nullptr) <<
1156 { 220 {
1157 wasAlreadyCreated = true; << 221 newElectronOccupancy . RemoveElectron(orbitToFree,1);
1158 molConf->SetLabel(label); << 222 newElectronOccupancy . AddElectron(orbitToFill,1);
1159 return molConf; <<
1160 } 223 }
1161 if(molConf->fLabel->empty()) << 224 else
1162 { 225 {
1163 wasAlreadyCreated = true; << 226 G4String errMsg = "There is no electron on the orbit " + G4UIcommand::ConvertToString(orbitToFree) +
1164 molConf->SetLabel(label); << 227 " you want to free. The molecule's name is "+ GetName();
1165 return molConf; << 228 G4Exception("G4Molecule::MoveOneElectron","",FatalErrorInArgument, errMsg);
>> 229 PrintState();
1166 } 230 }
1167 231
1168 molConf->PrintState(); << 232 return ChangeConfiguration(newElectronOccupancy);
1169 G4ExceptionDescription errMsg ; <<
1170 errMsg << "A molecular configuration for <<
1171 << molDef->GetName() <<
1172 << " has already been created " <<
1173 "with user ID " <<
1174 << molConf->fUserIdentifier << " a <<
1175 << molConf->GetLabel(); <<
1176 G4Exception("G4MolecularConfiguration::Cr <<
1177 "DOUBLE_CREATION", <<
1178 FatalErrorInArgument, <<
1179 errMsg); <<
1180 // KILL APP <<
1181 } <<
1182 else <<
1183 { <<
1184 auto newConf = <<
1185 new G4MolecularConfiguration(molDef, <<
1186 label, <<
1187 molDef->Ge <<
1188 newConf->fUserIdentifier = userIdentifier <<
1189 <<
1190 GetManager()->AddUserID(userIdentifier, n <<
1191 <<
1192 // G4MoleculeTable::Instance()-> <<
1193 // RecordMolecularConfiguration(userId <<
1194 return newConf; <<
1195 } <<
1196 return molConf; <<
1197 } 233 }
1198 234
1199 //___________________________________________ << 235 const G4String& G4MolecularConfiguration::GetName() const
1200 <<
1201 G4MolecularConfiguration* <<
1202 G4MolecularConfiguration:: <<
1203 CreateMolecularConfiguration(const G4String& <<
1204 const G4Molecule <<
1205 const G4String& <<
1206 const G4Electron <<
1207 bool& wasAlready <<
1208 { 236 {
1209 assert(label != ""); << 237 if(fName.isNull())
1210 wasAlreadyCreated = false; <<
1211 <<
1212 G4MolecularConfiguration* molConf = <<
1213 GetManager()->GetMolecularConfiguration <<
1214 <<
1215 if(molConf != nullptr) <<
1216 { <<
1217 if(molConf->GetElectronOccupancy() != nul <<
1218 { 238 {
1219 if(*molConf->GetElectronOccupancy() == << 239 fName = fMoleculeDefinition->GetName();
1220 { << 240 fName+= "^";
1221 if((molConf->fLabel != nullptr) && *m << 241 fName+= "{";
1222 { << 242 fName+= G4UIcommand::ConvertToString(fDynCharge);
1223 wasAlreadyCreated = true; << 243 fName+= "}";
1224 return molConf; <<
1225 } <<
1226 if(molConf->fLabel == nullptr) <<
1227 { <<
1228 wasAlreadyCreated = true; <<
1229 molConf->SetLabel(label); <<
1230 return molConf; <<
1231 } <<
1232 if(molConf->fLabel->empty()) <<
1233 { <<
1234 wasAlreadyCreated = true; <<
1235 molConf->SetLabel(label); <<
1236 return molConf; <<
1237 } <<
1238 } <<
1239 } 244 }
1240 << 245 return fName;
1241 <<
1242 molConf->PrintState(); <<
1243 G4ExceptionDescription errMsg ; <<
1244 errMsg << "A molecular configuration for <<
1245 << molDef->GetName() <<
1246 << " has already been created " <<
1247 "with user ID " <<
1248 << molConf->fUserIdentifier <<
1249 << " and possible different electr <<
1250 G4Exception("G4MolecularConfiguration::Cr <<
1251 "DOUBLE_CREATION", <<
1252 FatalErrorInArgument, <<
1253 errMsg); <<
1254 } <<
1255 else <<
1256 { <<
1257 auto newConf = <<
1258 new G4MolecularConfiguration(molDef, <<
1259 eOcc, <<
1260 label); <<
1261 newConf->fUserIdentifier = userIdentifier <<
1262 <<
1263 GetManager()->AddUserID(userIdentifier, n <<
1264 <<
1265 // G4MoleculeTable::Instance()-> <<
1266 // RecordMolecularConfiguration(userId <<
1267 return newConf; <<
1268 } <<
1269 return molConf; <<
1270 } <<
1271 <<
1272 <<
1273 //___________________________________________ <<
1274 <<
1275 G4MolecularConfiguration* <<
1276 G4MolecularConfiguration::G4MolecularConfigur <<
1277 GetOrCreateMolecularConfiguration(const G4Mol <<
1278 const G4Ele <<
1279 { <<
1280 auto it1 = fElecOccTable.find(molDef); <<
1281 <<
1282 if(it1 == fElecOccTable.end()) <<
1283 { <<
1284 return new G4MolecularConfiguration(molDe <<
1285 } <<
1286 <<
1287 ElectronOccupancyTable& table2 = it1->secon <<
1288 auto it = table2.find(eOcc); <<
1289 <<
1290 if(it == table2.end()) <<
1291 { <<
1292 auto molConf = <<
1293 new G4MolecularConfiguration(molDef, <<
1294 // molConf->Finalize(); <<
1295 return molConf; <<
1296 } <<
1297 <<
1298 return it->second; <<
1299 } 246 }
1300 247
1301 //___________________________________________ << 248 G4int G4MolecularConfiguration::GetAtomsNumber() const
1302 <<
1303 G4MolecularConfiguration* <<
1304 G4MolecularConfiguration::G4MolecularConfigur <<
1305 GetOrCreateMolecularConfiguration(const G4Mol <<
1306 int charge) <<
1307 { <<
1308 auto it1 = fChargeTable.find(molDef); <<
1309 <<
1310 if(it1 == fChargeTable.end()) <<
1311 { <<
1312 G4AutoLock lock(&fMoleculeCreationMutex); <<
1313 <<
1314 auto newConf = new G4MolecularConfigurat <<
1315 return newConf ; <<
1316 } <<
1317 <<
1318 ChargeTable& table2 = it1->second; <<
1319 auto it = table2.find(charge); <<
1320 <<
1321 if(it == table2.end()) <<
1322 { <<
1323 G4AutoLock lock(&fMoleculeCreationMutex); <<
1324 <<
1325 auto newConf = <<
1326 new G4MolecularConfiguration(molDef, <<
1327 // newConf->Finalize(); <<
1328 return newConf ; <<
1329 } <<
1330 <<
1331 return it->second; <<
1332 } <<
1333 <<
1334 //___________________________________________ <<
1335 <<
1336 void G4MolecularConfiguration::Serialize(std: <<
1337 { <<
1338 G4String moleculeName = fMoleculeDefinition <<
1339 WRITE(out, moleculeName); <<
1340 <<
1341 // if(fLabel) <<
1342 // out << fLabel; <<
1343 // else <<
1344 // out << ""; <<
1345 WRITE(out,fDynDiffusionCoefficient); <<
1346 WRITE(out,fDynVanDerVaalsRadius); <<
1347 WRITE(out,fDynDecayTime); <<
1348 WRITE(out,fDynMass); <<
1349 WRITE(out,fDynCharge); <<
1350 WRITE(out,fMoleculeID); <<
1351 WRITE(out,fFormatedName); <<
1352 WRITE(out,fName); <<
1353 WRITE(out,fIsFinalized); <<
1354 } <<
1355 <<
1356 //___________________________________________ <<
1357 <<
1358 void G4MolecularConfiguration::Unserialize(st <<
1359 { 249 {
1360 G4String moleculeName; << 250 return fMoleculeDefinition->GetAtomsNumber();
1361 READ(in, moleculeName); <<
1362 fMoleculeDefinition = <<
1363 G4MoleculeTable::Instance()->GetMolecul <<
1364 <<
1365 // G4String label; <<
1366 // <<
1367 // in.read((char*)(&label), sizeof(label)); <<
1368 // <<
1369 // if(label) <<
1370 // fLabel = new G4String(label); <<
1371 // else <<
1372 // fLabel = 0; <<
1373 READ(in,fDynDiffusionCoefficient); <<
1374 READ(in,fDynVanDerVaalsRadius); <<
1375 READ(in,fDynDecayTime); <<
1376 READ(in,fDynMass); <<
1377 READ(in,fDynCharge); <<
1378 READ(in,fMoleculeID); <<
1379 READ(in,fFormatedName); <<
1380 READ(in,fName); <<
1381 READ(in,fIsFinalized); <<
1382 } 251 }
1383 252
1384 //___________________________________________ << 253 G4double G4MolecularConfiguration::GetNbElectrons() const
1385 <<
1386 G4MolecularConfiguration* G4MolecularConfigur <<
1387 { 254 {
1388 return new G4MolecularConfiguration(in); << 255 return fElectronOccupancy->GetTotalOccupancy();
1389 } 256 }
1390 257
1391 //___________________________________________ << 258 void G4MolecularConfiguration::PrintState() const
1392 <<
1393 G4MolecularConfiguration::G4MolecularConfigur <<
1394 { 259 {
1395 fLabel = nullptr; // TODO: for now not seri << 260 G4cout<<"--------------Print electronic state of "<<GetName()<<"---------------"<<G4endl;
1396 Unserialize(in); << 261 fElectronOccupancy->DumpInfo();
1397 fMoleculeDefinition = nullptr; << 262 if(fElectronOccupancy==fMoleculeDefinition->GetGroundStateElectronOccupancy())
1398 fElectronOccupancy = nullptr; <<
1399 if(fElectronOccupancy != nullptr) <<
1400 { <<
1401 GetManager()->Insert(fMoleculeDefinition, <<
1402 fElectronOccupancy = <<
1403 GetManager()->FindCommonElectronOccup <<
1404 <<
1405 <<
1406 if(fLabel != nullptr) <<
1407 { 263 {
1408 GetManager()->RecordNewlyLabeledConfigu << 264 G4cout<<"At ground state"<<G4endl;
>> 265 }
>> 266 else
>> 267 {
>> 268 if(fMoleculeDefinition->GetDecayTable())
>> 269 G4cout<<"Transition :"<<(fMoleculeDefinition->GetDecayTable())->GetExcitedState(fElectronOccupancy)<<G4endl;
1409 } 270 }
1410 } <<
1411 else if(fLabel != nullptr) <<
1412 { <<
1413 fMoleculeID = GetManager()->Insert(fMolec <<
1414 } <<
1415 else if(fDynCharge != 0) <<
1416 { <<
1417 fMoleculeID = GetManager()->Insert(fMolec <<
1418 } <<
1419 } <<
1420 <<
1421 //___________________________________________ <<
1422 <<
1423 void G4MolecularConfiguration::SetUserID(cons <<
1424 { <<
1425 fUserIdentifier = userID; <<
1426 GetManager()->AddUserID(userID, this); <<
1427 // G4MoleculeTable::Instance()->RecordMolecu <<
1428 } <<
1429 <<
1430 //___________________________________________ <<
1431 <<
1432 double G4MolecularConfiguration::DiffCoeffWat <<
1433 { <<
1434 return pow(10, 4.311 <<
1435 - 2.722e3/temperature_K <<
1436 + 8.565e5/(temperature_K *temper <<
1437 - 1.181e8/(temperature_K*tempera <<
1438 } <<
1439 <<
1440 //___________________________________________ <<
1441 <<
1442 void <<
1443 G4MolecularConfiguration:: <<
1444 ScaleAllDiffusionCoefficientsOnWater(double t <<
1445 { <<
1446 double D_water_0 = DiffCoeffWater(fgTempera <<
1447 double D_water_f = DiffCoeffWater(temperatu <<
1448 <<
1449 G4cout << "Scaling factor = " << D_water_f/ <<
1450 <<
1451 G4ConfigurationIterator it = <<
1452 G4MoleculeTable::Instance()->GetConfigu <<
1453 <<
1454 while(it()) <<
1455 { <<
1456 G4MolecularConfiguration* conf = it.value <<
1457 double D_0 = conf->GetDiffusionCoefficien <<
1458 double D_f = D_water_f * D_0 /D_water_0; <<
1459 conf->SetDiffusionCoefficient(D_f); <<
1460 }; <<
1461 } <<
1462 <<
1463 //___________________________________________ <<
1464 <<
1465 void G4MolecularConfiguration::CreateDefaultD <<
1466 { <<
1467 if(!static_cast<bool>(fDiffParam)) <<
1468 { <<
1469 fDiffParam = &G4MolecularConfiguration::R <<
1470 } <<
1471 } <<
1472 <<
1473 //___________________________________________ <<
1474 <<
1475 void G4MolecularConfiguration::SetGlobalTempe <<
1476 { <<
1477 ScaleAllDiffusionCoefficientsOnWater(temper <<
1478 fgTemperature = temperature; <<
1479 } <<
1480 <<
1481 //___________________________________________ <<
1482 <<
1483 G4double G4MolecularConfiguration::GetGlobalT <<
1484 { <<
1485 return fgTemperature; <<
1486 } <<
1487 <<
1488 //___________________________________________ <<
1489 <<
1490 G4MolecularConfiguration* <<
1491 G4MolecularConfiguration:: <<
1492 G4MolecularConfigurationManager::GetMolecular <<
1493 { <<
1494 for(auto it : fMolConfPerID) <<
1495 { <<
1496 if(it->GetUserID() == userID) return it; <<
1497 } <<
1498 return nullptr; <<
1499 } <<
1500 <<
1501 //___________________________________________ <<
1502 <<
1503 G4MolecularConfiguration* <<
1504 G4MolecularConfiguration::GetMolecularConfigu <<
1505 { <<
1506 return GetManager()->GetMolecularConfigurat <<
1507 } 271 }
1508 272
1509 //___________________________________________ << 273 // added - to be transformed in a "Decay method"
1510 << 274 const vector <const G4MolecularDecayChannel*>* G4MolecularConfiguration::GetDecayChannel() const
1511 void G4MolecularConfiguration::FinalizeAll() <<
1512 { 275 {
1513 const std::vector<G4MolecularConfiguration* << 276 return fMoleculeDefinition-> GetDecayChannels(fElectronOccupancy);
1514 GetManager()->GetAllSpecies(); <<
1515 <<
1516 for(auto specie : species) <<
1517 { <<
1518 specie->Finalize(); <<
1519 } <<
1520 <<
1521 } 277 }
1522 278
1523 void G4MolecularConfiguration::PrintAll() //h << 279 G4int G4MolecularConfiguration::GetMoleculeID() const
1524 { 280 {
1525 const std::vector<G4MolecularConfiguration* << 281 if(fMoleculeDefinition)
1526 GetManager()->GetAllSpecies(); << 282 return fMoleculeDefinition->GetPDGEncoding();
1527 G4cout<<G4endl; << 283 else
1528 G4cout<<"Molecular Config"<<std::setw(25)<< << 284 G4Exception("G4Molecule::GetMoleculeID","",FatalErrorInArgument, "You should first enter a molecule defintion");
1529 G4cout<<"__________________________________ <<
1530 "________________________________ <<
1531 for(auto specie : species) <<
1532 { <<
1533 G4cout<<specie->GetName() <<
1534 <<std::setw(G4int(30 - specie->Get <<
1535 <<right<<specie->GetDiffusionCoeff <<
1536 <<specie->GetVanDerVaalsRadius()/C <<
1537 G4cout<<"________________________________ <<
1538 "______________________________ <<
1539 } <<
1540 285
>> 286 return INT_MAX;
1541 } 287 }
1542 288