| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // G4IonTable class implementation <<
27 // 23 //
28 // Author: H.Kurashige, 27 June 1998 << 24 // $Id: G4IonTable.cc,v 1.30 2001/10/15 09:58:34 kurasige Exp $
29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-04-00 $
>> 26 //
>> 27 //
>> 28 // --------------------------------------------------------------
>> 29 // GEANT 4 class implementation file
>> 30 //
>> 31 // History: first implementation, based on object model of
>> 32 // 27 June 1998 H.Kurashige
>> 33 // ---------------------------------------------------------------
>> 34 // modified GetIon 02 Aug., 98 H.Kurashige
>> 35 // added Remove() 06 Nov.,98 H.Kurashige
>> 36 // use G4NucleiPropoerties to get nuceli Mass 17 Nov.,98 H.Kurashige
>> 37 // use G4GenericIon for process List
>> 38 // modify fomula of Ion mass 09 Dec., 98 H.Kurashige
>> 39 // -----
>> 40 // Modified GetIon methods 17 Aug. 99 H.Kurashige
>> 41 // New design using G4VIsotopeTable 5 Oct. 99 H.Kurashige
>> 42 // Modified Element Name for Z>103 06 Apr. 01 H.Kurashige
30 43
31 #include "G4IonTable.hh" <<
32 44
33 #include "G4AutoDelete.hh" << 45 #include "G4IonTable.hh"
34 #include "G4HyperNucleiProperties.hh" <<
35 #include "G4Ions.hh" <<
36 #include "G4IsotopeProperty.hh" <<
37 #include "G4MuonicAtom.hh" <<
38 #include "G4MuonicAtomHelper.hh" <<
39 #include "G4NucleiProperties.hh" <<
40 #include "G4NuclideTable.hh" <<
41 #include "G4ParticleTable.hh" 46 #include "G4ParticleTable.hh"
42 #include "G4PhysicalConstants.hh" << 47 #include "G4Ions.hh"
43 #include "G4StateManager.hh" <<
44 #include "G4SystemOfUnits.hh" <<
45 #include "G4Threading.hh" <<
46 #include "G4UImanager.hh" 48 #include "G4UImanager.hh"
>> 49 #include "G4NucleiProperties.hh"
>> 50
>> 51 #include "G4IsotopeProperty.hh"
47 #include "G4VIsotopeTable.hh" 52 #include "G4VIsotopeTable.hh"
48 #include "G4ios.hh" <<
49 53
50 #include <algorithm> << 54 #include "G4ios.hh"
51 #include <iomanip> << 55 #include "g4std/iostream"
52 #include <iostream> << 56 #include "g4std/iomanip"
53 #include <sstream> <<
54 #include <vector> <<
55 <<
56 // It is very important for multithreaded Gean <<
57 // particle table pointer and the ion table po <<
58 // each worker thread hold its own copy of the <<
59 // ion list. This implementation is equivalent <<
60 // private. The two shadow ponters are used by <<
61 // content from the master thread. <<
62 // <<
63 G4ThreadLocal G4IonTable::G4IonList* G4IonTabl <<
64 G4ThreadLocal std::vector<G4VIsotopeTable*>* G <<
65 G4IonTable::G4IonList* G4IonTable::fIonListSha <<
66 std::vector<G4VIsotopeTable*>* G4IonTable::fIs <<
67 <<
68 namespace lightions <<
69 { <<
70 static const G4ParticleDefinition* p_proton = <<
71 static const G4ParticleDefinition* p_deuteron <<
72 static const G4ParticleDefinition* p_triton = <<
73 static const G4ParticleDefinition* p_alpha = n <<
74 static const G4ParticleDefinition* p_He3 = nul <<
75 void Init() <<
76 { <<
77 if (p_proton != nullptr) return; <<
78 p_proton = G4ParticleTable::GetParticleTable <<
79 p_deuteron = G4ParticleTable::GetParticleTab <<
80 p_triton = G4ParticleTable::GetParticleTable <<
81 p_alpha = G4ParticleTable::GetParticleTable( <<
82 p_He3 = G4ParticleTable::GetParticleTable()- <<
83 } <<
84 } // namespace lightions <<
85 <<
86 namespace antilightions <<
87 { <<
88 static const G4ParticleDefinition* p_proton = <<
89 static const G4ParticleDefinition* p_deuteron <<
90 static const G4ParticleDefinition* p_triton = <<
91 static const G4ParticleDefinition* p_alpha = n <<
92 static const G4ParticleDefinition* p_He3 = nul <<
93 void Init() <<
94 { <<
95 if (p_proton != nullptr) return; <<
96 p_proton = G4ParticleTable::GetParticleTable <<
97 p_deuteron = G4ParticleTable::GetParticleTab <<
98 p_triton = G4ParticleTable::GetParticleTable <<
99 p_alpha = G4ParticleTable::GetParticleTable( <<
100 p_He3 = G4ParticleTable::GetParticleTable()- <<
101 } <<
102 } // namespace antilightions <<
103 57
104 #ifdef G4MULTITHREADED << 58 #include "g4std/strstream"
105 G4Mutex G4IonTable::ionTableMutex = G4MUTEX_IN <<
106 #endif <<
107 59
108 // ------------------------------------------- <<
109 60
>> 61 ////////////////////
110 G4IonTable::G4IonTable() 62 G4IonTable::G4IonTable()
111 { 63 {
112 fIonList = new G4IonList(); 64 fIonList = new G4IonList();
113 << 65 fIsotopeTable = 0;
114 // Set up the shadow pointer used by worker <<
115 // <<
116 if (fIonListShadow == nullptr) { <<
117 fIonListShadow = fIonList; <<
118 } <<
119 <<
120 fIsotopeTableList = new std::vector<G4VIsoto <<
121 <<
122 // Set up the shadow pointer used by worker <<
123 // <<
124 if (fIsotopeTableListShadow == nullptr) { <<
125 fIsotopeTableListShadow = fIsotopeTableLis <<
126 } <<
127 <<
128 PrepareNuclideTable(); <<
129 RegisterIsotopeTable(pNuclideTable); <<
130 } 66 }
131 67
>> 68 ////////////////////
132 G4IonTable::~G4IonTable() 69 G4IonTable::~G4IonTable()
133 { 70 {
134 // delete IsotopeTable if existing << 71 // delete IsotopeTable if exists
135 if (fIsotopeTableList != nullptr) { << 72 if (fIsotopeTable != 0) delete fIsotopeTable;
136 for (const auto fIsotopeTable : *fIsotopeT << 73 fIsotopeTable =0;
137 if (fIsotopeTable != G4NuclideTable::Get <<
138 delete fIsotopeTable; <<
139 } <<
140 } <<
141 fIsotopeTableList->clear(); <<
142 delete fIsotopeTableList; <<
143 } <<
144 fIsotopeTableList = nullptr; <<
145 <<
146 if (fIonList == nullptr) return; <<
147 <<
148 // remove all contents in the Ion List <<
149 // No need to delete here because all partic <<
150 fIonList->clear(); <<
151 delete fIonList; <<
152 fIonList = nullptr; <<
153 } <<
154 <<
155 G4IonTable* G4IonTable::GetIonTable() <<
156 { <<
157 return G4ParticleTable::GetParticleTable()-> <<
158 } <<
159 <<
160 // Used by each worker thread to copy the cont <<
161 void G4IonTable::WorkerG4IonTable() <<
162 { <<
163 if (fIonList == nullptr) { <<
164 fIonList = new G4IonList(); <<
165 } <<
166 else { <<
167 fIonList->clear(); <<
168 } <<
169 74
170 for (const auto& it : *fIonListShadow) { << 75 if (fIonList ==0) return;
171 fIonList->insert(it); <<
172 } <<
173 <<
174 // Do not copy Isotope Table to Worker threa <<
175 // <<
176 if (fIsotopeTableList == nullptr) { <<
177 fIsotopeTableList = new std::vector<G4VIso <<
178 for (const auto i : *fIsotopeTableListShad <<
179 fIsotopeTableList->push_back(i); <<
180 } <<
181 } <<
182 } <<
183 76
184 void G4IonTable::InitializeLightIons() << 77 // delete ion objects
185 { << 78 G4ParticleDefinition* particle;
186 lightions::Init(); << 79 G4IonList::reverse_iterator i;
187 antilightions::Init(); << 80 for (i = fIonList->rbegin(); i!= fIonList->rend(); ++i) {
188 } << 81 particle = *i;
189 82
190 void G4IonTable::DestroyWorkerG4IonTable() << 83 if ( !IsLightIon(particle) ) {
191 { << 84 // delete if not static objects
192 // delete IsotopeTable if existing << 85 #ifdef G4VERBOSE
193 if (fIsotopeTableList != nullptr) { << 86 G4String name;
194 for (auto fIsotopeTable : *fIsotopeTableLi << 87 if (GetVerboseLevel()>1) {
195 if (fIsotopeTable != G4NuclideTable::Get << 88 G4cout << "G4IonTable:~IonTable() : delete ion of " ;
196 delete fIsotopeTable; << 89 G4cout << particle->GetParticleName() << G4endl;
197 } 90 }
>> 91 #endif
>> 92 delete particle;
198 } 93 }
199 fIsotopeTableList->clear(); <<
200 delete fIsotopeTableList; <<
201 } <<
202 fIsotopeTableList = nullptr; <<
203 94
204 if (fIonList == nullptr) return; << 95 }
205 96
206 // remove all contents in the Ion List << 97 // remove all contents in the Ion List
207 // No need to delete here because all partic <<
208 fIonList->clear(); 98 fIonList->clear();
>> 99
209 delete fIonList; 100 delete fIonList;
210 fIonList = nullptr; << 101 fIonList =0;
211 } 102 }
212 103
213 G4ParticleDefinition* G4IonTable::CreateIon(G4 <<
214 G4 <<
215 { <<
216 G4ParticleDefinition* ion = nullptr; <<
217 104
218 // check whether GenericIon has processes << 105 ////////////////////
219 G4ParticleDefinition* genericIon = G4Particl << 106 // -- CreateIon method ------
220 G4ProcessManager* pman = nullptr; << 107 ////////////////////
221 if (genericIon != nullptr) { << 108 G4ParticleDefinition* G4IonTable::CreateIon(G4int Z, G4int A, G4double E, G4int J)
222 pman = genericIon->GetProcessManager(); << 109 {
223 } << 110 G4ParticleDefinition* ion=0;
224 if ((genericIon == nullptr) || (genericIon-> << 111
>> 112 // get ion name
>> 113 G4String name = GetIonName(Z, A, E);
>> 114 if ( name(0) == '?') {
225 #ifdef G4VERBOSE 115 #ifdef G4VERBOSE
226 if (GetVerboseLevel() > 1) { << 116 if (GetVerboseLevel()>0) {
227 G4cout << "G4IonTable::CreateIon() : can << 117 G4cout << "G4IonTable::GetIon() : can not create ions " << G4endl;
228 << " Z =" << Z << " A = " << A < << 118 G4cout << " Z =" << Z << " A = " << A << G4endl;
229 } 119 }
230 #endif 120 #endif
231 G4Exception("G4IonTable::CreateIon()", "PA << 121 return 0;
232 "Can not create ions because G << 122 }
233 return nullptr; <<
234 } <<
235 123
236 G4double life = 0.0; << 124 G4double life = -1.0;
237 G4DecayTable* decayTable = nullptr; << 125 G4DecayTable* decayTable =0;
238 G4bool stable = true; 126 G4bool stable = true;
239 G4double mu = 0.0; << 127
240 G4double Eex = 0.0; << 128 G4IsotopeProperty* fProperty = FindIsotope(Z, A, E, J);
241 G4int lvl = 0; << 129 if (fProperty !=0 ){
242 G4int J = 0; << 130 J = fProperty->GetiSpin();
243 << 131 E = fProperty->GetEnergy();
244 const G4IsotopeProperty* fProperty = FindIso <<
245 if (fProperty != nullptr) { <<
246 Eex = fProperty->GetEnergy(); <<
247 lvl = fProperty->GetIsomerLevel(); <<
248 J = fProperty->GetiSpin(); <<
249 life = fProperty->GetLifeTime(); 132 life = fProperty->GetLifeTime();
250 mu = fProperty->GetMagneticMoment(); <<
251 decayTable = fProperty->GetDecayTable(); 133 decayTable = fProperty->GetDecayTable();
252 stable = (life <= 0.) || (decayTable == nu <<
253 lvl = fProperty->GetIsomerLevel(); <<
254 if (lvl < 0) lvl = 9; <<
255 } <<
256 else { <<
257 #ifdef G4VERBOSE <<
258 if (GetVerboseLevel() > 1) { <<
259 G4ExceptionDescription ed; <<
260 ed << "G4IonTable::CreateIon(): G4Isotop <<
261 << " Z = " << Z << " A = " << A << " <<
262 if (flb != G4Ions::G4FloatLevelBase::no_ <<
263 ed << " FloatingLevel +" << G4Ions::Fl <<
264 } <<
265 ed << ".\n" <<
266 << " Physics quantities such as life <<
267 G4Exception("G4IonTable::CreateIon()", " <<
268 } <<
269 #endif <<
270 // excitation energy <<
271 Eex = E; <<
272 // lvl is assigned to 9 temporarily <<
273 if (Eex > 0.0) lvl = 9; <<
274 } 134 }
275 << 135 stable = (life <= 0.);
276 // Eex = G4NuclideTable::Round(Eex); << 136 G4double mass = GetNucleusMass(Z, A)+ E;
277 if (Eex == 0.0) lvl = 0; << 137 G4double charge = G4double(Z)*eplus;
278 // ion name << 138
279 G4String name = ""; <<
280 /////////////if (lvl<9) name = GetIonName(Z, <<
281 if (lvl == 0 && flb == G4Ions::G4FloatLevelB <<
282 name = GetIonName(Z, A, lvl); <<
283 else <<
284 name = GetIonName(Z, A, Eex, flb); <<
285 <<
286 // PDG encoding <<
287 G4int encoding = GetNucleusEncoding(Z, A, E, <<
288 <<
289 // PDG mass <<
290 G4double mass = GetNucleusMass(Z, A) + Eex; <<
291 <<
292 // PDG charge is set to one of nucleus <<
293 G4double charge = G4double(Z) * eplus; <<
294 <<
295 // create an ion 139 // create an ion
296 // spin, parity, isospin values are fixed << 140 // spin, parity, isospin values are fixed
297 <<
298 // Request lock for particle table accesses. <<
299 // this critical region. <<
300 // 141 //
301 // clang-format off <<
302 ion = new G4Ions( name, mass, 142 ion = new G4Ions( name, mass, 0.0*MeV, charge,
303 J, +1, << 143 J, +1, 0,
304 0, 0, << 144 0, 0, 0,
305 "nucleus", 0, << 145 "nucleus", 0, A, 0,
306 stable, life, << 146 stable, life, decayTable);
307 "generic", 0, <<
308 Eex, lvl <<
309 // clang-format on <<
310 147
311 // Release lock for particle table accesses. << 148 // Set Excitation Energy
312 // << 149 ((G4Ions*)(ion))->SetExcitationEnergy(E);
313 ion->SetPDGMagneticMoment(mu); <<
314 static_cast<G4Ions*>(ion)->SetFloatLevelBase <<
315 <<
316 // No Anti particle registered <<
317 ion->SetAntiPDGEncoding(0); <<
318 150
319 #ifdef G4VERBOSE 151 #ifdef G4VERBOSE
320 if (GetVerboseLevel() > 1) { << 152 if (GetVerboseLevel()>1) {
321 G4cout << "G4IonTable::CreateIon() : creat << 153 G4cout << "G4IonTable::GetIon() : create ion of " << name << G4endl;
322 << " encoding=" << encoding; << 154 }
323 if (E > 0.0) { <<
324 G4cout << " IsomerLVL=" << lvl << " exci <<
325 } <<
326 G4cout << G4endl; <<
327 } <<
328 #endif 155 #endif
329 << 156
330 // Add process manager to the ion 157 // Add process manager to the ion
331 AddProcessManager(ion); << 158 AddProcessManager(name);
332 << 159
333 #ifdef G4MULTITHREADED << 160 // Set cut value same as "GenericIon"
334 // Fill decay channels if this method is inv << 161 SetCuts(ion);
335 if (G4Threading::IsWorkerThread()) { << 162
336 if (!stable && (decayTable != nullptr)) { << 163 if (fProperty !=0) delete fProperty;
337 G4int nCh = decayTable->entries(); <<
338 for (G4int iCh = 0; iCh < nCh; ++iCh) { <<
339 decayTable->GetDecayChannel(iCh)->GetD <<
340 } <<
341 } <<
342 } <<
343 #endif <<
344 <<
345 return ion; <<
346 } <<
347 <<
348 G4ParticleDefinition* G4IonTable::CreateIon(G4 <<
349 G4 <<
350 { <<
351 if (LL == 0) return CreateIon(Z, A, E, flb); <<
352 <<
353 // create hyper nucleus <<
354 G4ParticleDefinition* ion = nullptr; <<
355 <<
356 // check whether GenericIon has processes <<
357 G4ParticleDefinition* genericIon = G4Particl <<
358 G4ProcessManager* pman = nullptr; <<
359 if (genericIon != nullptr) pman = genericIon <<
360 if ((genericIon == nullptr) || (genericIon-> <<
361 #ifdef G4VERBOSE <<
362 if (GetVerboseLevel() > 1) { <<
363 G4cout << "G4IonTable::CreateIon() : can <<
364 << " Z =" << Z << " A = " << A < <<
365 } <<
366 #endif <<
367 G4Exception("G4IonTable::CreateIon()", "PA <<
368 "Can not create ions because G <<
369 return nullptr; <<
370 } <<
371 <<
372 G4int J = 0; <<
373 G4double life = 0.0; <<
374 G4DecayTable* decayTable = nullptr; <<
375 G4bool stable = true; <<
376 <<
377 // excitation energy <<
378 // G4double Eex = G4NuclideTable::Round(E); <<
379 G4double Eex = E; <<
380 G4double mass = GetNucleusMass(Z, A, LL) + E <<
381 G4int lvl = 0; <<
382 // lvl is assigned to 9 temporarily <<
383 if (Eex > 0.0) lvl = 9; <<
384 <<
385 // PDG encoding <<
386 G4int encoding = GetNucleusEncoding(Z, A, LL <<
387 <<
388 // PDG charge is set to one of nucleus <<
389 G4double charge = G4double(Z) * eplus; <<
390 <<
391 // create an ion <<
392 // spin, parity, isospin values are fixed <<
393 // <<
394 // get ion name <<
395 G4String name = GetIonName(Z, A, LL, Eex, fl <<
396 <<
397 // clang-format off <<
398 ion = new G4Ions( name, mass, <<
399 J, +1, <<
400 0, 0, <<
401 "nucleus", 0, <<
402 stable, life, <<
403 "generic", 0, <<
404 Eex, lvl <<
405 // clang-format on <<
406 <<
407 // Release lock for particle table accesses <<
408 <<
409 G4double mu = 0.0; // magnetic moment <<
410 ion->SetPDGMagneticMoment(mu); <<
411 static_cast<G4Ions*>(ion)->SetFloatLevelBase <<
412 <<
413 // No Anti particle registered <<
414 ion->SetAntiPDGEncoding(0); <<
415 <<
416 #ifdef G4VERBOSE <<
417 if (GetVerboseLevel() > 1) { <<
418 G4cout << "G4IonTable::CreateIon() : creat <<
419 << ", " << LL << " encoding=" << en <<
420 if (E > 0.0) { <<
421 G4cout << " IsomerLVL=" << lvl << " exci <<
422 } <<
423 G4cout << G4endl; <<
424 } <<
425 #endif <<
426 <<
427 // Add process manager to the ion <<
428 AddProcessManager(ion); <<
429 <<
430 return ion; 164 return ion;
431 } 165 }
432 166
433 G4ParticleDefinition* G4IonTable::CreateIon(G4 << 167 ////////////////////
>> 168 // -- GetIon methods ------
>> 169 ////////////////////
>> 170 G4ParticleDefinition* G4IonTable::GetIon(G4int Z, G4int A, G4int J, G4int Q)
434 { 171 {
435 // always create an ion for any lvl << 172 return GetIon(Z, A);
436 return CreateIon(Z, A, 0.0, G4Ions::FloatLev <<
437 } 173 }
438 174
439 G4ParticleDefinition* G4IonTable::CreateIon(G4 << 175 ////////////////////
>> 176 G4ParticleDefinition* G4IonTable::GetIon(G4int Z, G4int A, G4int J)
440 { 177 {
441 return (LL == 0) ? CreateIon(Z, A, 0.0, G4Io << 178 return GetIon( Z, A, 0.0, J);
442 : CreateIon(Z, A, LL, 0.0, <<
443 } <<
444 <<
445 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
446 { <<
447 return GetIon(Z, A, 0.0, G4Ions::G4FloatLeve <<
448 } <<
449 <<
450 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
451 { <<
452 return (LL == 0) ? GetIon(Z, A, 0.0, G4Ions: <<
453 : GetIon(Z, A, LL, 0.0, G4I <<
454 } 179 }
455 180
>> 181 ////////////////////
456 G4ParticleDefinition* G4IonTable::GetIon(G4int 182 G4ParticleDefinition* G4IonTable::GetIon(G4int Z, G4int A, G4double E, G4int J)
457 { 183 {
458 return GetIon(Z, A, E, G4Ions::G4FloatLevelB << 184 if ( (A<1) || (Z>numberOfElements) || (Z<=0) || (J<0) || (E<0.0) ) {
459 } <<
460 <<
461 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
462 { <<
463 return GetIon(Z, A, E, G4Ions::FloatLevelBas <<
464 } <<
465 <<
466 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
467 G4int <<
468 { <<
469 if ((A < 1) || (Z <= 0) || (E < 0.0) || (A > <<
470 #ifdef G4VERBOSE <<
471 if (GetVerboseLevel() > 0) { <<
472 G4cout << "G4IonTable::GetIon() : illega <<
473 << " Z =" << Z << " A = " << A < <<
474 } <<
475 #endif <<
476 return nullptr; <<
477 } <<
478 auto flb1 = flb; <<
479 <<
480 // Search ions with A, Z <<
481 G4ParticleDefinition* ion = FindIon(Z, A, E, <<
482 <<
483 // find out ground state floating level <<
484 if (ion == nullptr && E == 0.0) { <<
485 const G4IsotopeProperty* fProperty = FindI <<
486 if (nullptr != fProperty) { <<
487 flb1 = fProperty->GetFloatLevelBase(); <<
488 if (flb != flb1) { <<
489 ion = FindIon(Z, A, E, flb1, J); <<
490 } <<
491 } <<
492 } <<
493 <<
494 // create ion <<
495 #ifdef G4MULTITHREADED <<
496 if (ion == nullptr) { <<
497 if (G4Threading::IsWorkerThread()) { <<
498 G4MUTEXLOCK(&G4IonTable::ionTableMutex); <<
499 ion = FindIonInMaster(Z, A, E, flb1, J); <<
500 if (ion == nullptr) ion = CreateIon(Z, A <<
501 InsertWorker(ion); <<
502 G4MUTEXUNLOCK(&G4IonTable::ionTableMutex <<
503 } <<
504 else { <<
505 ion = CreateIon(Z, A, E, flb1); <<
506 } <<
507 } <<
508 #else <<
509 if (ion == nullptr) ion = CreateIon(Z, A, E, <<
510 #endif <<
511 <<
512 return ion; <<
513 } <<
514 <<
515 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
516 { <<
517 return GetIon(Z, A, LL, E, G4Ions::G4FloatLe <<
518 } <<
519 <<
520 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
521 G4int <<
522 { <<
523 return GetIon(Z, A, LL, E, G4Ions::FloatLeve <<
524 } <<
525 <<
526 G4ParticleDefinition* G4IonTable::GetIon(G4int <<
527 G4Ion <<
528 { <<
529 if (LL == 0) return GetIon(Z, A, E, flb, J); <<
530 <<
531 if (A < 2 || Z < 0 || Z > A - LL || LL > A | <<
532 #ifdef G4VERBOSE <<
533 if (GetVerboseLevel() > 0) { <<
534 G4cout << "G4IonTable::GetIon() : illega <<
535 << " Z =" << Z << " A = " << A < <<
536 } <<
537 #endif <<
538 return nullptr; <<
539 } <<
540 if (A == 2) { <<
541 #ifdef G4VERBOSE 185 #ifdef G4VERBOSE
542 if (GetVerboseLevel() > 0) { << 186 if (GetVerboseLevel()>0) {
543 G4cout << "G4IonTable::GetIon() : No bou << 187 G4cout << "G4IonTable::GetIon() : illegal atomic number/mass" << G4endl;
544 << " Z =" << Z << " A = " << A < << 188 G4cout << " Z =" << Z << " A = " << A << " E = " << E/keV << G4endl;
545 } 189 }
546 #endif 190 #endif
547 return nullptr; << 191 G4cerr << "G4IonTable::GetIon called with Z="<<Z<<", A="<<A<<G4endl;
>> 192 G4Exception("G4IonTable::GetIon : illegal atomic number/mass ");
548 } 193 }
549 194
550 // Search ions with A, Z << 195 // Search ions with A, Z
551 G4ParticleDefinition* ion = FindIon(Z, A, LL << 196 G4ParticleDefinition* ion = FindIon(Z,A,E,J);
552 197
553 // create ion 198 // create ion
554 #ifdef G4MULTITHREADED << 199 if (ion == 0) {
555 if (ion == nullptr) { << 200 ion = CreateIon(Z, A, E, J);
556 if (G4Threading::IsWorkerThread()) { <<
557 G4MUTEXLOCK(&G4IonTable::ionTableMutex); <<
558 ion = FindIonInMaster(Z, A, LL, E, flb, <<
559 if (ion == nullptr) ion = CreateIon(Z, A <<
560 InsertWorker(ion); <<
561 G4MUTEXUNLOCK(&G4IonTable::ionTableMutex <<
562 } <<
563 else { <<
564 ion = CreateIon(Z, A, LL, E, flb); <<
565 } <<
566 } 201 }
567 #else <<
568 if (ion == nullptr) ion = CreateIon(Z, A, LL <<
569 #endif <<
570 <<
571 return ion; <<
572 } <<
573 202
574 G4ParticleDefinition* G4IonTable::GetIon(G4int << 203 return ion;
575 { <<
576 G4int Z, A, LL, IsoLvl; <<
577 G4double E; <<
578 if (!GetNucleusByEncoding(encoding, Z, A, LL <<
579 #ifdef G4VERBOSE <<
580 if (GetVerboseLevel() > 0) { <<
581 G4cout << "G4IonTable::GetIon() : illega <<
582 << " CODE:" << encoding << G4endl <<
583 } <<
584 #endif <<
585 G4Exception("G4IonTable::GetIon()", "PART1 <<
586 return nullptr; <<
587 } <<
588 return GetIon(Z, A, LL, IsoLvl); <<
589 } 204 }
590 205
>> 206 ////////////////////
591 G4ParticleDefinition* G4IonTable::FindIon(G4in 207 G4ParticleDefinition* G4IonTable::FindIon(G4int Z, G4int A, G4double E, G4int J)
592 { 208 {
593 return FindIon(Z, A, E, G4Ions::G4FloatLevel << 209 const G4double EnergyTorelance = 0.1 * keV;
594 } <<
595 210
596 G4ParticleDefinition* G4IonTable::FindIon(G4in << 211 if ( (A<1) || (Z>numberOfElements) || (Z<=0) || (J<0) || (E<0.0)) {
597 { <<
598 return FindIon(Z, A, E, G4Ions::FloatLevelBa <<
599 } <<
600 <<
601 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
602 G4Io <<
603 { <<
604 if ((A < 1) || (Z <= 0) || (J < 0) || (E < 0 <<
605 #ifdef G4VERBOSE 212 #ifdef G4VERBOSE
606 if (GetVerboseLevel() > 0) { << 213 if (GetVerboseLevel()>0) {
607 G4cout << "G4IonTable::FindIon(): illega << 214 G4cout << "G4IonTable::FindIon() : illegal atomic number/mass or excitation level " << G4endl;
608 << " or excitation level:" << G4e << 215 G4cout << " Z =" << Z << " A = " << A << " E = " << E/keV << G4endl;
609 << " E = " << E / keV << G4endl; <<
610 } 216 }
611 #endif 217 #endif
612 G4Exception("G4IonTable::FindIon()", "PART << 218 return 0;
613 return nullptr; <<
614 } 219 }
615 // Search ions with A, Z ,E 220 // Search ions with A, Z ,E
616 // !! J is omitted now !! << 221 // !! J is moitted now !!
617 const G4ParticleDefinition* ion = nullptr; << 222 G4ParticleDefinition* ion=0;
618 G4bool isFound = false; <<
619 <<
620 // check if light ion <<
621 ion = GetLightIon(Z, A); <<
622 if (ion != nullptr && E == 0.0) { <<
623 // light ion <<
624 isFound = true; <<
625 } <<
626 else { <<
627 // -- loop over all particles in Ion table <<
628 G4int encoding = GetNucleusEncoding(Z, A); <<
629 const G4ParticleDefinition* ion1 = nullptr <<
630 for (auto i = fIonList->find(encoding); i <<
631 ion = i->second; <<
632 if ((ion->GetAtomicNumber() != Z) || (io <<
633 // excitation level <<
634 G4double anExcitaionEnergy = ((const G4I <<
635 <<
636 if (std::fabs(E - anExcitaionEnergy) < p <<
637 if (nullptr == ion1) ion1 = ion; <<
638 if (((const G4Ions*)(ion))->GetFloatLe <<
639 isFound = true; <<
640 break; <<
641 } <<
642 } <<
643 } <<
644 // rerun search on ground level without ch <<
645 if (!isFound && E == 0.0 && nullptr != ion <<
646 isFound = true; <<
647 ion = ion1; <<
648 } <<
649 } <<
650 <<
651 if (isFound) { <<
652 return const_cast<G4ParticleDefinition*>(i <<
653 } <<
654 <<
655 return nullptr; <<
656 } <<
657 <<
658 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
659 { <<
660 return (LL == 0) ? FindIon(Z, A, E, G4Ions:: <<
661 : FindIon(Z, A, LL, E, G4Io <<
662 } <<
663 <<
664 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
665 G4in <<
666 { <<
667 return FindIon(Z, A, LL, E, G4Ions::FloatLev <<
668 } <<
669 <<
670 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
671 G4Io <<
672 { <<
673 if (LL == 0) return FindIon(Z, A, E, flb, J) <<
674 <<
675 if (A < 2 || Z < 0 || Z > A - LL || LL > A | <<
676 #ifdef G4VERBOSE <<
677 if (GetVerboseLevel() > 0) { <<
678 G4cout << "G4IonTable::FindIon(): illega <<
679 << " or excitation level:" << G4e <<
680 << " E = " << E / keV << G4endl; <<
681 } <<
682 #endif <<
683 G4Exception("G4IonTable::FindIon()", "PART <<
684 return nullptr; <<
685 } <<
686 // Search ions with A, Z ,E <<
687 // !! J is omitted now !! <<
688 const G4ParticleDefinition* ion = nullptr; <<
689 G4bool isFound = false; 223 G4bool isFound = false;
690 224
691 // -- loop over all particles in Ion table 225 // -- loop over all particles in Ion table
692 G4int encoding = GetNucleusEncoding(Z, A, LL << 226 G4IonList::iterator idx;
693 for (auto i = fIonList->find(encoding); i != << 227 for (idx = fIonList->begin(); idx!= fIonList->end(); ++idx) {
694 ion = i->second; << 228 ion = *idx;
695 if ((ion->GetAtomicNumber() != Z) || (ion- << 229
696 if (ion->GetQuarkContent(3) != LL) break; << 230 // Z = Atomic Number
>> 231 G4int anAtomicNumber = 0;
>> 232 // A = baryon number
>> 233 G4int anAtomicMass = 0;
697 // excitation level 234 // excitation level
698 G4double anExcitaionEnergy = ((const G4Ion << 235 G4double anExcitaionEnergy =0.0;
699 if (std::fabs(E - anExcitaionEnergy) < pNu <<
700 if (((const G4Ions*)(ion))->GetFloatLeve <<
701 isFound = true; <<
702 break; <<
703 } <<
704 } <<
705 } <<
706 <<
707 if (isFound) { <<
708 return const_cast<G4ParticleDefinition*>(i <<
709 } <<
710 <<
711 return nullptr; <<
712 } <<
713 <<
714 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
715 { <<
716 return FindIon(Z, A, 0.0, G4Ions::FloatLevel <<
717 } <<
718 <<
719 G4ParticleDefinition* G4IonTable::FindIon(G4in <<
720 { <<
721 return (LL == 0) ? FindIon(Z, A, 0.0, G4Ions <<
722 : FindIon(Z, A, LL, 0.0, G4 <<
723 } <<
724 <<
725 G4int G4IonTable::GetNucleusEncoding(G4int Z, <<
726 { <<
727 // PDG code for Ions <<
728 // Nuclear codes are given as 10-digit numbe <<
729 // For a nucleus consisting of np protons an <<
730 // A = np + nn and Z = np. <<
731 // I gives the isomer level, with I = 0 corr <<
732 // to the ground state and I >0 to excitatio <<
733 <<
734 if (Z == 1 && A == 1 && E == 0.0) return 221 <<
735 <<
736 G4int encoding = 1000000000; <<
737 encoding += Z * 10000; <<
738 encoding += A * 10; <<
739 if (lvl > 0 && lvl < 10) <<
740 encoding += lvl; // isomer level <<
741 else if (E > 0.0) <<
742 encoding += 9; // isomer level <<
743 <<
744 return encoding; <<
745 } <<
746 <<
747 G4int G4IonTable::GetNucleusEncoding(G4int Z, <<
748 { <<
749 // Get PDG code for Hyper-Nucleus Ions <<
750 // Nuclear codes are given as 10-digit numbe <<
751 // For a nucleus consisting of np protons an <<
752 // A = np + nn +nlambda and Z = np. <<
753 // LL = nlambda <<
754 // I gives the isomer level, with I = 0 corr <<
755 // to the ground state and I >0 to excitatio <<
756 <<
757 G4int encoding = GetNucleusEncoding(Z, A, E, <<
758 if (LL == 0) return encoding; <<
759 encoding += LL * 10000000; <<
760 if (Z == 1 && A == 1 && E == 0.0) encoding = <<
761 <<
762 return encoding; <<
763 } <<
764 <<
765 G4bool G4IonTable::GetNucleusByEncoding(G4int <<
766 { <<
767 if (encoding <= 0) return false; // anti pa <<
768 236
769 if (encoding == 2212) // proton << 237 if ( IsLightIon(ion) ) {
770 { << 238 anAtomicNumber = G4int(ion->GetPDGCharge()/eplus);
771 Z = 1; << 239 anAtomicMass = ion->GetBaryonNumber();
772 A = 1; << 240 anExcitaionEnergy = 0.0;
773 E = 0.0; << 241
774 lvl = 0; << 242 } else {
775 return true; << 243 anAtomicNumber = ((const G4Ions*)(ion))->GetAtomicNumber();
776 } << 244 anAtomicMass = ((const G4Ions*)(ion))->GetAtomicMass();
777 << 245 anExcitaionEnergy = ((const G4Ions*)(ion))->GetExcitationEnergy();
778 encoding -= 1000000000; << 246 }
779 Z = encoding / 10000; << 247
780 encoding -= 10000 * Z; << 248 if ( (A == anAtomicMass) &&
781 A = encoding / 10; << 249 (Z == anAtomicNumber ) &&
782 lvl = encoding % 10; << 250 ( abs(E - anExcitaionEnergy ) < EnergyTorelance ) ) {
783 return true; << 251 isFound = true;
784 } << 252 break;
785 <<
786 G4bool G4IonTable::GetNucleusByEncoding(G4int <<
787 G4int& <<
788 { <<
789 if (encoding <= 0) return false; // anti pa <<
790 <<
791 if (encoding == 3122) // Lambda <<
792 { <<
793 Z = 1; <<
794 A = 1; <<
795 LL = 1; <<
796 E = 0.0; <<
797 lvl = 0; <<
798 return true; <<
799 } <<
800 <<
801 if (encoding % 10 != 0) { <<
802 // !!!not supported for excitation states <<
803 return false; <<
804 } <<
805 if (encoding < 1000000000) { <<
806 // anti particle <<
807 return false; <<
808 } <<
809 <<
810 encoding -= 1000000000; <<
811 LL = encoding / 10000000; <<
812 encoding -= 10000000 * LL; <<
813 Z = encoding / 10000; <<
814 encoding -= 10000 * Z; <<
815 A = encoding / 10; <<
816 lvl = encoding % 10; <<
817 return true; <<
818 } <<
819 <<
820 G4String G4IonTable::GetIonName(G4int Z, G4int <<
821 G4Ions::G4Floa <<
822 { <<
823 G4String name = GetIonName(Z, A, 0); <<
824 <<
825 // Excited energy or floating level <<
826 if (E > 0 || flb != G4Ions::G4FloatLevelBase <<
827 std::ostringstream os; <<
828 os.setf(std::ios::fixed); <<
829 os.precision(3); <<
830 // Excited nucleus <<
831 os << '[' << E / keV; <<
832 if (flb != G4Ions::G4FloatLevelBase::no_Fl <<
833 os << G4Ions::FloatLevelBaseChar(flb); <<
834 } 253 }
835 os << ']'; <<
836 name += os.str(); <<
837 } <<
838 <<
839 return name; <<
840 } <<
841 <<
842 G4String G4IonTable::GetIonName(G4int Z, G4int <<
843 G4Ions::G4Floa <<
844 { <<
845 if (LL == 0) return GetIonName(Z, A, E, flb) <<
846 G4String name = ""; <<
847 for (G4int i = 0; i < LL; ++i) { <<
848 name += "L"; <<
849 } <<
850 name += GetIonName(Z, A, E, flb); <<
851 return name; <<
852 } <<
853 <<
854 G4String G4IonTable::GetIonName(G4int Z, G4int <<
855 { <<
856 std::ostringstream os; <<
857 <<
858 // Atomic number <<
859 if ((0 < Z) && (Z <= numberOfElements)) { <<
860 os << elementName[Z - 1]; <<
861 } 254 }
862 else { <<
863 os << "E" << Z << "-"; <<
864 } <<
865 // Atomic Mass <<
866 os << A; <<
867 255
868 if (lvl > 0) { << 256 if ( isFound ){
869 // Isomer level for Excited nucelus << 257 return ion;
870 os << '[' << lvl << ']'; << 258 } else {
>> 259 return 0;
871 } 260 }
872 G4String name = os.str(); <<
873 return name; <<
874 } 261 }
875 262
876 G4String G4IonTable::GetIonName(G4int Z, G4int << 263 /////////////////
877 { << 264 G4String G4IonTable::GetIonName(G4int Z, G4int A, G4double E) const
878 if (LL == 0) return GetIonName(Z, A, lvl); << 265 {
879 G4String name = ""; << 266 G4String name;
880 for (G4int i = 0; i < LL; ++i) { << 267 if ( (0< Z) && (Z <=numberOfElements) ) {
881 name += "L"; << 268 name = elementName[Z-1];
882 } << 269 } else {
883 name += GetIonName(Z, A, lvl); << 270 return "?";
>> 271 }
>> 272 char val[50];
>> 273 G4std::ostrstream os(val,50);
>> 274 os.setf(G4std::ios::fixed);
>> 275 os << A << '[' << G4std::setprecision(1) << E/keV << ']' << '\0';
>> 276 name += val;
884 return name; 277 return name;
885 } 278 }
886 279
887 G4bool G4IonTable::IsIon(const G4ParticleDefin <<
888 { <<
889 // Return true if the particle is ion <<
890 static const G4String nucleus("nucleus"); <<
891 static const G4String proton("proton"); <<
892 <<
893 // Neutron is not ion <<
894 if ((particle->GetAtomicMass() > 0) && (part <<
895 return particle->GetBaryonNumber() > 0; <<
896 } <<
897 <<
898 // Particles derived from G4Ions <<
899 if (particle->GetParticleType() == nucleus) <<
900 280
901 // Proton (Hydrogen nucleus) << 281 /////////////////
902 if (particle->GetParticleName() == proton) r << 282 G4bool G4IonTable::IsIon(G4ParticleDefinition* particle)
903 <<
904 return false; <<
905 } <<
906 <<
907 G4bool G4IonTable::IsAntiIon(const G4ParticleD <<
908 { 283 {
909 // Return true if the particle is ion << 284 // return true if the particle is ion
910 static const G4String anti_nucleus("anti_nuc <<
911 static const G4String anti_proton("anti_prot <<
912 <<
913 // Anti_neutron is not ion <<
914 if ((particle->GetAtomicMass() > 0) && (part <<
915 return particle->GetBaryonNumber() < 0; <<
916 } <<
917 <<
918 // Particles derived from G4Ions <<
919 if (particle->GetParticleType() == anti_nucl <<
920 <<
921 // Anti_proton (Anti_Hydrogen nucleus) <<
922 if (particle->GetParticleName() == anti_prot <<
923 285
924 return false; << 286 // particles derived from G4VIon and G4Ions
925 } << 287 G4bool value = (particle->GetParticleType() == "nucleus");
926 288
927 G4bool G4IonTable::IsLightIon(const G4Particle << 289 // proton (Hydrogen nucleus)
928 { << 290 value = value || (particle->GetParticleName() == "proton");
929 static const std::string names[] = {"proton" <<
930 291
931 // Return true if the particle is pre-define << 292 return value;
932 return std::find(names, names + 5, (particle <<
933 } 293 }
934 294
935 G4bool G4IonTable::IsLightAntiIon(const G4Part << 295 /////////////////
>> 296 G4bool G4IonTable::IsLightIon(G4ParticleDefinition* particle) const
936 { 297 {
937 static const std::string names[] = {"anti_pr << 298 // return true if the particle is pre-defined ion
938 "anti_He << 299 G4String name = particle->GetParticleName();
939 300
940 // Return true if the particle is pre-define << 301 G4bool value = (name == "proton");
941 return std::find(names, names + 5, (particle << 302 value = value || (name == "neutron");
942 } << 303 value = value || (name == "alpha");
>> 304 value = value || (name == "deuteron");
>> 305 value = value || (name == "triton") ;
>> 306 value = value || (name == "He3");
>> 307 value = value || (name == "GenericIon") ;
>> 308
>> 309 return value;
>> 310 }
943 311
>> 312 /////////////////
944 G4ParticleDefinition* G4IonTable::GetLightIon( 313 G4ParticleDefinition* G4IonTable::GetLightIon(G4int Z, G4int A) const
945 { 314 {
946 // Returns pointer to pre-defined ions << 315 // returns pointer to pre-defined ions
947 const G4ParticleDefinition* ion = nullptr; <<
948 if ((Z <= 2)) { <<
949 #ifndef G4MULTITHREADED <<
950 // In sequential use lazy-initialization <<
951 lightions::Init(); <<
952 #endif <<
953 if ((Z == 1) && (A == 1)) { <<
954 ion = lightions::p_proton; <<
955 } <<
956 else if ((Z == 1) && (A == 2)) { <<
957 ion = lightions::p_deuteron; <<
958 } <<
959 else if ((Z == 1) && (A == 3)) { <<
960 ion = lightions::p_triton; <<
961 } <<
962 else if ((Z == 2) && (A == 4)) { <<
963 ion = lightions::p_alpha; <<
964 } <<
965 else if ((Z == 2) && (A == 3)) { <<
966 ion = lightions::p_He3; <<
967 } <<
968 } <<
969 return const_cast<G4ParticleDefinition*>(ion <<
970 } <<
971 316
972 G4ParticleDefinition* G4IonTable::GetLightAnti << 317 G4ParticleDefinition* ion=0;
973 { << 318 if ( (Z<=2) ) {
974 // Returns pointer to pre-defined ions << 319 if ( (Z==1)&&(A==1) ) {
975 const G4ParticleDefinition* ion = nullptr; << 320 ion = G4ParticleTable::GetParticleTable()->FindParticle("proton"); // proton
976 if ((Z <= 2)) { << 321
977 #ifndef G4MULTITHREADED << 322 } else if ( (Z==0)&&(A==1) ) {
978 // In sequential use lazy-initialization << 323 ion = G4ParticleTable::GetParticleTable()->FindParticle("neutron"); // neutron
979 antilightions::Init(); << 324 } else if ( (Z==1)&&(A==2) ) {
980 #endif << 325 ion = G4ParticleTable::GetParticleTable()->FindParticle("deuteron"); // deuteron
981 if ((Z == 1) && (A == 1)) { << 326 } else if ( (Z==1)&&(A==3) ) {
982 ion = antilightions::p_proton; << 327 ion = G4ParticleTable::GetParticleTable()->FindParticle("triton"); // tritoon
983 } << 328 } else if ( (Z==2)&&(A==4) ) {
984 else if ((Z == 1) && (A == 2)) { << 329 ion = G4ParticleTable::GetParticleTable()->FindParticle("alpha"); // alpha
985 ion = antilightions::p_deuteron; << 330
986 } << 331 } else if ( (Z==2)&&(A==3) ) {
987 else if ((Z == 1) && (A == 3)) { << 332 ion = G4ParticleTable::GetParticleTable()->FindParticle("He3"); // He3
988 ion = antilightions::p_triton; <<
989 } <<
990 else if ((Z == 2) && (A == 4)) { <<
991 ion = antilightions::p_alpha; <<
992 } <<
993 else if ((Z == 2) && (A == 3)) { <<
994 ion = antilightions::p_He3; <<
995 } 333 }
996 } 334 }
997 return const_cast<G4ParticleDefinition*>(ion << 335 return ion;
998 } 336 }
999 337
1000 G4double G4IonTable::GetNucleusMass(G4int Z, << 338 /////////////////
>> 339 // -- GetNucleusMass/GetIonMass ---
>> 340 /////////////////
>> 341 G4double G4IonTable::GetNucleusMass(G4int Z, G4int A) const
1001 { 342 {
1002 if ((A < 1) || (Z < 0) || (LL < 0) || (lvl << 343 if ( (A<1) || (Z>numberOfElements) || (Z<0)) {
1003 #ifdef G4VERBOSE 344 #ifdef G4VERBOSE
1004 if (GetVerboseLevel() > 0) { << 345 if (GetVerboseLevel()>0) {
1005 G4cout << "G4IonTable::GetNucleusMass() << 346 G4cout << "G4IonTable::GetNucleusMass() : illegal atomic number/mass " << G4endl;
1006 << " Z =" << Z << " A = " << A << 347 G4cout << " Z =" << Z << " A = " << A << G4endl;
1007 } 348 }
1008 #endif 349 #endif
1009 G4Exception("G4IonTable::GetNucleusMass() << 350 G4Exception("G4IonTable::GetNucleusMass() : illegal atomic number/mass ");
1010 "illegal atomic number/mass") <<
1011 return -1.0; <<
1012 } 351 }
1013 352
>> 353 // calculate nucleus mass
>> 354 G4ParticleDefinition* ion=GetLightIon(Z, A);
1014 G4double mass; 355 G4double mass;
1015 if (LL == 0) { <<
1016 // calculate nucleus mass <<
1017 const G4ParticleDefinition* ion = GetLigh <<
1018 356
1019 if (ion != nullptr) { << 357 if (ion!=0) {
1020 mass = ion->GetPDGMass(); << 358 mass = ion->GetPDGMass();
1021 } << 359
1022 else { << 360 } else {
1023 // Use G4NucleiProperties::GetNuclearMa << 361
1024 mass = G4NucleiProperties::GetNuclearMa << 362 // use G4NucleiProperties::GetNuclearMass
1025 } << 363 mass = G4NucleiProperties::GetNuclearMass(A, Z);
1026 364
1027 // Isomer <<
1028 if (lvl > 0) { <<
1029 // -- loop over all particles in Ion ta <<
1030 G4int encoding = GetNucleusEncoding(Z, <<
1031 G4bool isFound = false; <<
1032 for (auto i = fIonList->find(encoding); <<
1033 ion = i->second; <<
1034 if ((ion->GetAtomicNumber() != Z) || <<
1035 // Excitation level <<
1036 if (((const G4Ions*)(ion))->GetIsomer <<
1037 isFound = true; <<
1038 break; <<
1039 } <<
1040 } <<
1041 if (isFound) { <<
1042 // Return existing isomer mass <<
1043 mass = ion->GetPDGMass(); <<
1044 } <<
1045 else { <<
1046 // Find isomer from IsotopeTable <<
1047 const G4IsotopeProperty* fProperty = <<
1048 if (fProperty != nullptr) mass += fPr <<
1049 } <<
1050 } <<
1051 } <<
1052 else { <<
1053 mass = G4HyperNucleiProperties::GetNuclea <<
1054 } 365 }
1055 return mass; <<
1056 } <<
1057 366
1058 G4double G4IonTable::GetIsomerMass(G4int Z, G << 367 return mass;
1059 { <<
1060 return GetNucleusMass(Z, A, 0, lvl); <<
1061 } 368 }
1062 369
1063 G4double G4IonTable::GetIonMass(G4int Z, G4in << 370 //////////////////
>> 371 G4double G4IonTable::GetIonMass(G4int Z, G4int A) const
1064 { 372 {
1065 return GetNucleusMass(Z, A, LL, lvl); << 373 return GetNucleusMass(Z,A);
1066 } 374 }
1067 375
1068 void G4IonTable::clear() <<
1069 { <<
1070 if (G4ParticleTable::GetParticleTable()->Ge <<
1071 G4Exception("G4IonTable::clear()", "PART1 <<
1072 "No effects because readyToUs <<
1073 return; <<
1074 } <<
1075 <<
1076 #ifdef G4VERBOSE <<
1077 if (GetVerboseLevel() > 2) { <<
1078 G4cout << "G4IonTable::Clear() : number o <<
1079 G4cout << fIonList->size() << G4endl; <<
1080 } <<
1081 #endif <<
1082 fIonList->clear(); <<
1083 } <<
1084 376
1085 void G4IonTable::Insert(const G4ParticleDefin << 377 /////////////////
>> 378 // -- Methods for handling conatiner ---
>> 379 /////////////////
>> 380 void G4IonTable::Insert(G4ParticleDefinition* particle)
1086 { 381 {
1087 if (!IsIon(particle)) return; << 382 if (IsIon(particle)) {
1088 if (Contains(particle)) return; << 383 fIonList->push_back(particle);
1089 << 384 } else {
1090 G4int Z = particle->GetAtomicNumber(); << 385 //#ifdef G4VERBOSE
1091 G4int A = particle->GetAtomicMass(); << 386 //if (GetVerboseLevel()>0) {
1092 G4int LL = particle->GetQuarkContent(3); / << 387 // G4cout << "G4IonTable::Insert :" << particle->GetParticleName() ;
1093 G4int encoding = GetNucleusEncoding(Z, A, L << 388 // G4cout << " is not ions" << G4endl;
1094 << 389 //}
1095 // Register the ion with its encoding of th << 390 //#endif
1096 fIonListShadow->insert(std::pair<const G4in <<
1097 } <<
1098 <<
1099 void G4IonTable::InsertWorker(const G4Particl <<
1100 { <<
1101 if (particle == nullptr) return; <<
1102 <<
1103 G4int Z = particle->GetAtomicNumber(); <<
1104 G4int A = particle->GetAtomicMass(); <<
1105 G4int LL = particle->GetQuarkContent(3); / <<
1106 G4int encoding = GetNucleusEncoding(Z, A, L <<
1107 G4bool found = false; <<
1108 if (encoding != 0) { <<
1109 for (auto i = fIonList->find(encoding); i <<
1110 if (particle == i->second) { <<
1111 found = true; <<
1112 break; <<
1113 } <<
1114 } <<
1115 } 391 }
1116 if (found) return; <<
1117 <<
1118 // Register the ion with its encoding of th <<
1119 fIonList->insert(std::pair<const G4int, con <<
1120 } 392 }
1121 393
1122 void G4IonTable::Remove(const G4ParticleDefin << 394 /////////////////
>> 395 void G4IonTable::Remove(G4ParticleDefinition* particle)
1123 { 396 {
1124 if (particle == nullptr) return; <<
1125 #ifdef G4MULTITHREADED <<
1126 if (G4Threading::IsWorkerThread()) { <<
1127 G4ExceptionDescription ed; <<
1128 ed << "Request of removing " << particle- <<
1129 << " is ignored as it is invoked from <<
1130 G4Exception("G4IonTable::Remove()", "PART <<
1131 return; <<
1132 } <<
1133 #endif <<
1134 if (G4ParticleTable::GetParticleTable()->Ge <<
1135 G4StateManager* pStateManager = G4StateMa <<
1136 G4ApplicationState currentState = pStateM <<
1137 if (currentState != G4State_PreInit) { <<
1138 G4String msg = "Request of removing "; <<
1139 msg += particle->GetParticleName(); <<
1140 msg += " has No effects other than Pre_ <<
1141 G4Exception("G4IonTable::Remove()", "PA <<
1142 return; <<
1143 } <<
1144 <<
1145 #ifdef G4VERBOSE <<
1146 if (GetVerboseLevel() > 0) { <<
1147 G4cout << particle->GetParticleName() < <<
1148 } <<
1149 #endif <<
1150 } <<
1151 <<
1152 if (IsIon(particle)) { 397 if (IsIon(particle)) {
1153 G4int Z = particle->GetAtomicNumber(); << 398 G4IonList::iterator idx;
1154 G4int A = particle->GetAtomicMass(); << 399 for (idx = fIonList->begin(); idx!= fIonList->end(); ++idx) {
1155 G4int LL = particle->GetQuarkContent(3); << 400 if ( particle == *idx) {
1156 G4int encoding = GetNucleusEncoding(Z, A, << 401 fIonList->erase(idx);
1157 if (encoding != 0) { <<
1158 for (auto i = fIonListShadow->find(enco <<
1159 if (particle == i->second) { <<
1160 fIonListShadow->erase(i); <<
1161 break; <<
1162 } <<
1163 } 402 }
1164 } 403 }
1165 } << 404 } else {
1166 else { <<
1167 #ifdef G4VERBOSE 405 #ifdef G4VERBOSE
1168 if (GetVerboseLevel() > 1) { << 406 if (GetVerboseLevel()>0) {
1169 G4cout << "G4IonTable::Remove :" << par << 407 G4cout << "G4IonTable::Remove :" << particle->GetParticleName() ;
>> 408 G4cout << " is not ions" << G4endl;
1170 } 409 }
1171 #endif 410 #endif
1172 } 411 }
>> 412
1173 } 413 }
1174 414
1175 void G4IonTable::DumpTable(const G4String& pa << 415
>> 416
>> 417 /////////////////
>> 418 // -- Dump Information
>> 419 /////////////////
>> 420 void G4IonTable::DumpTable(const G4String &particle_name) const
1176 { 421 {
1177 const G4ParticleDefinition* ion; << 422 G4ParticleDefinition* ion;
1178 for (const auto& idx : *fIonList) { << 423 G4IonList::iterator idx;
1179 ion = idx.second; << 424 for (idx = fIonList->begin(); idx!= fIonList->end(); ++idx) {
1180 if ((particle_name == "ALL") || (particle << 425 ion = *idx;
>> 426 if (( particle_name == "ALL" ) || (particle_name == "all")){
1181 ion->DumpTable(); 427 ion->DumpTable();
1182 } << 428 } else if ( particle_name == ion->GetParticleName() ) {
1183 else if (particle_name == ion->GetParticl <<
1184 ion->DumpTable(); 429 ion->DumpTable();
1185 } 430 }
1186 } 431 }
1187 } 432 }
1188 433
1189 // ------------------------------------------ << 434 /////////////////
1190 // << 435 const G4String G4IonTable::elementName[] = {
1191 // clang-format off <<
1192 const G4String G4IonTable::elementName[] = <<
1193 { <<
1194 "H", 436 "H", "He",
1195 "Li", "Be", 437 "Li", "Be", "B", "C", "N", "O", "F", "Ne",
1196 "Na", "Mg", 438 "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar",
1197 "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe 439 "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
1198 "Rb", "Sr", "Y", "Zr", "Nb", "Mo","Tc", "Ru 440 "Rb", "Sr", "Y", "Zr", "Nb", "Mo","Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe",
1199 "Cs", "Ba", 441 "Cs", "Ba",
1200 "La", "Ce", "Pr", "Nd", "Pm", " 442 "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
1201 "Hf", "Ta", "W", "Re", "Os 443 "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn",
1202 "Fr", "Ra", 444 "Fr", "Ra",
1203 "Ac", "Th", "Pa", "U", "Np", " 445 "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr",
1204 "Rf", "Db", "Sg", "Bh", "Hs", " << 446 "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Xa"
>> 447
1205 }; 448 };
1206 // clang-format on <<
1207 449
>> 450
>> 451 /////////////////
1208 G4int G4IonTable::GetVerboseLevel() const 452 G4int G4IonTable::GetVerboseLevel() const
1209 { 453 {
1210 return G4ParticleTable::GetParticleTable()- 454 return G4ParticleTable::GetParticleTable()->GetVerboseLevel();
1211 } 455 }
1212 456
1213 void G4IonTable::AddProcessManager(G4Particle << 457 /////////////////
>> 458 void G4IonTable::AddProcessManager(const G4String& name)
1214 { 459 {
1215 if (ion->IsGeneralIon()) { << 460 // create command string for addProcManager
1216 // Check whether GenericIon has processes << 461 char cmdAdd[60];
1217 G4ParticleDefinition* genericIon = G4Part << 462 G4std::ostrstream osAdd(cmdAdd,60);
1218 << 463 osAdd << "/run/particle/addProcManager "<< name << '\0';
1219 G4ProcessManager* pman = nullptr; <<
1220 if (genericIon != nullptr) pman = generic <<
1221 if ((genericIon == nullptr) || (genericIo <<
1222 { <<
1223 G4String msg = "G4IonTable::AddProcessM <<
1224 msg += ion->GetParticleName(); <<
1225 msg += "\n because GenericIon is not av <<
1226 G4Exception("G4IonTable::AddProcessMana <<
1227 return; <<
1228 } <<
1229 464
1230 ion->SetParticleDefinitionID(genericIon-> << 465 // set /control/verbose 0
1231 } << 466 G4int tempVerboseLevel = G4UImanager::GetUIpointer()->GetVerboseLevel();
1232 else { << 467 G4UImanager::GetUIpointer()->SetVerboseLevel(0);
1233 // Is this a MuonicAtom ? <<
1234 auto muatom = dynamic_cast<G4MuonicAtom*> <<
1235 468
1236 if (muatom != nullptr) { << 469 // issue /run/particle/addProcManage
1237 #ifdef G4VERBOSE << 470 G4UImanager::GetUIpointer()->ApplyCommand(cmdAdd);
1238 if (GetVerboseLevel() > 1) { <<
1239 G4cout << "G4IonTable::AddProcessMana <<
1240 << "MuonicAtom dynamic_cast su <<
1241 } <<
1242 #endif <<
1243 // Check whether GenericMuonicAtom has <<
1244 G4ParticleDefinition* genericMA = G4Par <<
1245 471
1246 G4ProcessManager* pman = nullptr; << 472 // retreive /control/verbose
1247 if (genericMA != nullptr) pman = generi << 473 G4UImanager::GetUIpointer()->SetVerboseLevel(tempVerboseLevel);
1248 if ((genericMA == nullptr) || (genericM <<
1249 { <<
1250 G4String msg = "G4IonTable::AddProces <<
1251 msg += ion->GetParticleName(); <<
1252 msg += "\n because GenericMuonicAtom <<
1253 G4Exception("G4IonTable::AddProcessMa <<
1254 return; <<
1255 } <<
1256 <<
1257 ion->SetParticleDefinitionID(genericMA- <<
1258 } <<
1259 else { <<
1260 G4String msg = "G4IonTable::AddProcessM <<
1261 msg += ion->GetParticleName(); <<
1262 msg += "\n because of unsupported parti <<
1263 G4Exception("G4IonTable::AddProcessMana <<
1264 return; <<
1265 } <<
1266 } <<
1267 return; <<
1268 } 474 }
1269 475
1270 void G4IonTable::RegisterIsotopeTable(G4VIsot << 476 #include "g4std/vector"
>> 477 /////////////////
>> 478 void G4IonTable::SetCuts(G4ParticleDefinition* ion)
1271 { 479 {
1272 // check duplication << 480 // Set cut value same as "GenericIon"
1273 G4String name = table->GetName(); << 481 G4ParticleDefinition* genericIon=G4ParticleTable::GetParticleTable()->FindParticle("GenericIon");
1274 for (const auto fIsotopeTable : *fIsotopeTa << 482 if (genericIon == 0) {
1275 if (name == fIsotopeTable->GetName()) ret << 483 G4Exception("G4IonTable::SetCuts : GenericIon is not defined !!");
1276 } << 484 }
1277 // register <<
1278 fIsotopeTableList->push_back(table); <<
1279 } <<
1280 485
1281 G4VIsotopeTable* G4IonTable::GetIsotopeTable( << 486 if (genericIon->GetEnergyCuts() != 0) {
1282 { << 487 G4std::vector<G4double> cuts;
1283 G4VIsotopeTable* fIsotopeTable = nullptr; << 488 for (size_t j=0; j<G4Material::GetNumberOfMaterials(); j +=1) {
1284 if (index < fIsotopeTableList->size()) { << 489 cuts.push_back( (genericIon->GetLengthCuts())[j] );
1285 fIsotopeTable = (*fIsotopeTableList)[inde << 490 }
1286 } << 491 ion->SetRangeCutVector(cuts);
1287 return fIsotopeTable; <<
1288 } <<
1289 <<
1290 G4IsotopeProperty* G4IonTable::FindIsotope(G4 <<
1291 G4 <<
1292 { <<
1293 if (fIsotopeTableList == nullptr) return nu <<
1294 if (fIsotopeTableList->empty()) return null <<
1295 <<
1296 G4IsotopeProperty* property = nullptr; <<
1297 <<
1298 for (std::size_t i = 0; i < fIsotopeTableLi <<
1299 G4VIsotopeTable* fIsotopeTable = (*fIsoto <<
1300 property = fIsotopeTable->GetIsotope(Z, A <<
1301 if (property != nullptr) break; <<
1302 } <<
1303 <<
1304 return property; <<
1305 } <<
1306 <<
1307 G4IsotopeProperty* G4IonTable::FindIsotope(G4 <<
1308 { <<
1309 if (fIsotopeTableList == nullptr) return nu <<
1310 if (fIsotopeTableList->empty()) return null <<
1311 <<
1312 G4IsotopeProperty* property = nullptr; <<
1313 <<
1314 // iterate <<
1315 for (std::size_t i = 0; i < fIsotopeTableLi <<
1316 G4VIsotopeTable* fIsotopeTable = (*fIsoto <<
1317 property = fIsotopeTable->GetIsotope(Z, A <<
1318 if (property != nullptr) break; <<
1319 } <<
1320 <<
1321 return property; <<
1322 } <<
1323 <<
1324 void G4IonTable::CreateAllIon() <<
1325 { <<
1326 PreloadNuclide(); <<
1327 } <<
1328 <<
1329 void G4IonTable::CreateAllIsomer() <<
1330 { <<
1331 PreloadNuclide(); <<
1332 } <<
1333 492
1334 void G4IonTable::PrepareNuclideTable() << 493 G4String name = ion->GetParticleName();
1335 { <<
1336 if (pNuclideTable == nullptr) pNuclideTable <<
1337 } <<
1338 494
1339 void G4IonTable::PreloadNuclide() << 495 // Build Physics Tables for the ion
1340 { << 496 // create command string for buildPhysicsTable
1341 if (isIsomerCreated || !G4Threading::IsMult << 497 char cmdBld[60];
>> 498 G4std::ostrstream osBld(cmdBld,60);
>> 499 osBld << "/run/particle/buildPhysicsTable "<< name << '\0';
>> 500
>> 501 // set /control/verbose 0
>> 502 G4int tempVerboseLevel = G4UImanager::GetUIpointer()->GetVerboseLevel();
>> 503 G4UImanager::GetUIpointer()->SetVerboseLevel(0);
1342 504
1343 pNuclideTable->GenerateNuclide(); << 505 // issue /run/particle/buildPhysicsTable
>> 506 G4UImanager::GetUIpointer()->ApplyCommand(cmdBld);
1344 507
1345 for (std::size_t i = 0; i != pNuclideTable- << 508 // retreive /control/verbose
1346 const G4IsotopeProperty* fProperty = pNuc << 509 G4UImanager::GetUIpointer()->SetVerboseLevel(tempVerboseLevel);
1347 G4int Z = fProperty->GetAtomicNumber(); <<
1348 G4int A = fProperty->GetAtomicMass(); <<
1349 G4double Eex = fProperty->GetEnergy(); <<
1350 GetIon(Z, A, Eex); <<
1351 } <<
1352 510
1353 isIsomerCreated = true; << 511 } else {
1354 } <<
1355 <<
1356 G4ParticleDefinition* G4IonTable::GetParticle <<
1357 { <<
1358 if ((index >= 0) && (index < Entries())) { <<
1359 auto idx = fIonList->cbegin(); <<
1360 G4int counter = 0; <<
1361 while (idx != fIonList->cend()) // Loop <<
1362 { <<
1363 if (counter == index) { <<
1364 return const_cast<G4ParticleDefinitio <<
1365 } <<
1366 ++counter; <<
1367 ++idx; <<
1368 } <<
1369 } <<
1370 #ifdef G4VERBOSE 512 #ifdef G4VERBOSE
1371 if (GetVerboseLevel() > 1) { << 513 if (GetVerboseLevel()> 1) {
1372 G4cout << " G4IonTable::GetParticle" << 514 G4cout << "G4IonTable::GetIon() : ";
1373 << " invalid index (=" << index << << 515 G4cout << " cut value of GenericIon has not be defined yet";
1374 << " entries = " << Entries() << G << 516 }
1375 } << 517 #endif
1376 #endif <<
1377 return nullptr; <<
1378 } <<
1379 <<
1380 G4bool G4IonTable::Contains(const G4ParticleD <<
1381 { <<
1382 if (!IsIon(particle)) return false; <<
1383 518
1384 G4int Z = particle->GetAtomicNumber(); <<
1385 G4int A = particle->GetAtomicMass(); <<
1386 G4int LL = particle->GetQuarkContent(3); / <<
1387 G4int encoding = GetNucleusEncoding(Z, A, L <<
1388 G4bool found = false; <<
1389 if (encoding != 0) { <<
1390 for (auto i = fIonListShadow->find(encodi <<
1391 if (particle == i->second) { <<
1392 found = true; <<
1393 break; <<
1394 } <<
1395 } <<
1396 } 519 }
1397 return found; <<
1398 } 520 }
1399 521
1400 G4int G4IonTable::Entries() const << 522 ////////////////////
>> 523 void G4IonTable::RegisterIsotopeTable(G4VIsotopeTable* table)
1401 { 524 {
1402 return (G4int)fIonList->size(); << 525 fIsotopeTable = table;
1403 } 526 }
1404 527
1405 G4int G4IonTable::size() const << 528 ////////////////////
>> 529 G4VIsotopeTable* G4IonTable::GetIsotopeTable() const
1406 { 530 {
1407 return (G4int)fIonList->size(); << 531 return fIsotopeTable;
1408 } <<
1409 <<
1410 G4ParticleDefinition* G4IonTable::FindIonInMa <<
1411 <<
1412 { <<
1413 // Search ions with A, Z ,E <<
1414 // !! J is omitted now !! <<
1415 const G4ParticleDefinition* ion = nullptr; <<
1416 G4bool isFound = false; <<
1417 <<
1418 // -- loop over all particles in Ion table <<
1419 G4int encoding = GetNucleusEncoding(Z, A); <<
1420 for (auto i = fIonListShadow->find(encoding <<
1421 ion = i->second; <<
1422 if ((ion->GetAtomicNumber() != Z) || (ion <<
1423 // excitation level <<
1424 G4double anExcitaionEnergy = ((const G4Io <<
1425 if (std::fabs(E - anExcitaionEnergy) < pN <<
1426 if (((const G4Ions*)(ion))->GetFloatLev <<
1427 isFound = true; <<
1428 break; <<
1429 } <<
1430 } <<
1431 } <<
1432 <<
1433 if (isFound) { <<
1434 return const_cast<G4ParticleDefinition*>( <<
1435 } <<
1436 <<
1437 return nullptr; <<
1438 } 532 }
1439 533
1440 G4ParticleDefinition* G4IonTable::FindIonInMa <<
1441 <<
1442 { <<
1443 if (LL == 0) return FindIon(Z, A, E, flb, J <<
1444 <<
1445 // Search ions with A, Z ,E <<
1446 // !! J is omitted now !! <<
1447 const G4ParticleDefinition* ion = nullptr; <<
1448 G4bool isFound = false; <<
1449 <<
1450 // -- loop over all particles in Ion table <<
1451 G4int encoding = GetNucleusEncoding(Z, A, L <<
1452 for (auto i = fIonListShadow->find(encoding <<
1453 ion = i->second; <<
1454 if ((ion->GetAtomicNumber() != Z) || (ion <<
1455 if (ion->GetQuarkContent(3) != LL) break; <<
1456 // Excitation level <<
1457 G4double anExcitaionEnergy = ((const G4Io <<
1458 if (std::fabs(E - anExcitaionEnergy) < pN <<
1459 if (((const G4Ions*)(ion))->GetFloatLev <<
1460 isFound = true; <<
1461 break; <<
1462 } <<
1463 } <<
1464 } <<
1465 <<
1466 if (isFound) { <<
1467 return const_cast<G4ParticleDefinition*>( <<
1468 } <<
1469 534
1470 return nullptr; << 535 ////////////////////
1471 } << 536 G4IsotopeProperty* G4IonTable::FindIsotope(G4int Z, G4int A, G4double E, G4int J)
1472 <<
1473 G4ParticleDefinition* G4IonTable::FindIonInMa <<
1474 { 537 {
1475 // Search ions with A, Z ,E << 538 if (fIsotopeTable ==0) return 0;
1476 // !! J is omitted now !! <<
1477 const G4ParticleDefinition* ion = nullptr; <<
1478 G4bool isFound = false; <<
1479 <<
1480 // -- loop over all particles in Ion table <<
1481 G4int encoding = GetNucleusEncoding(Z, A); <<
1482 for (auto i = fIonListShadow->find(encoding <<
1483 ion = i->second; <<
1484 if ((ion->GetAtomicNumber() != Z) || (ion <<
1485 // Excitation level <<
1486 if (((const G4Ions*)(ion))->GetIsomerLeve <<
1487 isFound = true; <<
1488 break; <<
1489 } <<
1490 } <<
1491 539
1492 if (isFound) { << 540 // ask IsotopeTable // ask IsotopeTable
1493 return const_cast<G4ParticleDefinition*>( << 541 return fIsotopeTable->GetIsotope(Z,A,E);
1494 } <<
1495 <<
1496 return nullptr; <<
1497 } 542 }
1498 543
1499 G4ParticleDefinition* G4IonTable::FindIonInMa <<
1500 { <<
1501 if (LL == 0) return FindIon(Z, A, lvl); <<
1502 544
1503 // Search ions with A, Z ,E, lvl <<
1504 const G4ParticleDefinition* ion = nullptr; <<
1505 G4bool isFound = false; <<
1506 545
1507 // -- loop over all particles in Ion table <<
1508 G4int encoding = GetNucleusEncoding(Z, A, L <<
1509 for (auto i = fIonListShadow->find(encoding <<
1510 ion = i->second; <<
1511 if ((ion->GetAtomicNumber() != Z) || (ion <<
1512 if (ion->GetQuarkContent(3) != LL) break; <<
1513 // excitation level <<
1514 if (((const G4Ions*)(ion))->GetIsomerLeve <<
1515 isFound = true; <<
1516 break; <<
1517 } <<
1518 } <<
1519 546
1520 if (isFound) { <<
1521 return const_cast<G4ParticleDefinition*>( <<
1522 } <<
1523 547
1524 return nullptr; <<
1525 } <<
1526 548
1527 G4double G4IonTable::GetLifeTime(const G4Part <<
1528 { <<
1529 if ((particle->IsGeneralIon()) && (pNuclide <<
1530 G4Exception("G4IonTable::GetLifeTime()", <<
1531 "Method is invoked before G4I <<
1532 return 0.; <<
1533 } <<
1534 return particle->GetPDGLifeTime(); <<
1535 } <<
1536 549
1537 G4double G4IonTable::GetLifeTime(G4int Z, G4i <<
1538 { <<
1539 return GetLifeTime(Z, A, E, G4Ions::FloatLe <<
1540 } <<
1541 550
1542 G4double G4IonTable::GetLifeTime(G4int Z, G4i <<
1543 { <<
1544 G4double life = -1001.0; <<
1545 const G4IsotopeProperty* fProperty = FindIs <<
1546 if (fProperty != nullptr) life = fProperty- <<
1547 return life; <<
1548 } <<
1549 551
1550 G4ParticleDefinition* G4IonTable::GetMuonicAt <<
1551 { <<
1552 if (base == nullptr || !IsIon(base)) { <<
1553 G4Exception("G4IonTable::GetMuonicAtom()" <<
1554 "Constructor argument is not <<
1555 return nullptr; <<
1556 } <<
1557 552
1558 // We're assuming here that we get a base t <<
1559 // constructed and unexcited ... strip exci <<
1560 // isomers from the encoding <<
1561 <<
1562 auto const Z = base->GetAtomicNumber(); <<
1563 auto const A = base->GetAtomicMass(); <<
1564 auto const baseenc = GetNucleusEncoding(Z, <<
1565 auto const encoding = baseenc + 1000000000; <<
1566 <<
1567 // We have to do all the MT manipulations m <<
1568 // convenience functions assume a G4Ions wi <<
1569 // they recalculate the encoding from parti <<
1570 // than using the carried member function v <<
1571 // do operations on the base ion, rather th <<
1572 // G4MuonicAtom <<
1573 <<
1574 auto i = fIonList->find(encoding); <<
1575 if (i != fIonList->cend()) { <<
1576 return const_cast<G4ParticleDefinition*>( <<
1577 } <<
1578 // not in threadlocal list; check global li <<
1579 #ifdef G4MULTITHREADED <<
1580 if (G4Threading::IsWorkerThread()) { <<
1581 G4MUTEXLOCK(&G4IonTable::ionTableMutex); <<
1582 i = fIonListShadow->find(encoding); <<
1583 auto end = fIonListShadow->cend(); <<
1584 G4MUTEXUNLOCK(&G4IonTable::ionTableMutex) <<
1585 if (i != end) { <<
1586 // we found it, stuff it into the threa <<
1587 fIonList->insert(*i); <<
1588 // and then return it ... <<
1589 return const_cast<G4ParticleDefinition* <<
1590 } <<
1591 } <<
1592 #endif <<
1593 553
1594 // not found in either list; create and pot <<
1595 auto const name = "Mu" + GetIonName(Z, A); <<
1596 554
1597 G4MuonicAtom* muatom = G4MuonicAtomHelper:: <<
1598 555
1599 // Not sure this is doing the right thing.. <<
1600 AddProcessManager(muatom); <<
1601 556
1602 // Now, we have to push the muatom into the <<
1603 // first, recheck global list, in case anot <<
1604 // before us and created this same muatom <<
1605 <<
1606 #ifdef G4MULTITHREADED <<
1607 if (G4Threading::IsWorkerThread()) { <<
1608 G4MUTEXLOCK(&G4IonTable::ionTableMutex); <<
1609 // first, we need to make sure it hasn't <<
1610 // other thread <<
1611 auto j = fIonListShadow->find(encoding); <<
1612 if (j != fIonListShadow->cend()) { <<
1613 // oops ... someone else built a copy w <<
1614 // cleanup our instantiation, and take <<
1615 // the global list <<
1616 delete muatom; <<
1617 muatom = const_cast<G4MuonicAtom*>(stat <<
1618 } <<
1619 else { <<
1620 // otherwise, push onto the global list <<
1621 fIonListShadow->insert(std::make_pair(e <<
1622 } <<
1623 G4MUTEXUNLOCK(&G4IonTable::ionTableMutex) <<
1624 } <<
1625 #endif <<
1626 // in either case, push onto the the thread <<
1627 fIonList->insert(std::make_pair(encoding, m <<
1628 <<
1629 return muatom; <<
1630 } <<
1631 <<
1632 G4ParticleDefinition* G4IonTable::GetMuonicAt <<
1633 { <<
1634 // Need the cast because we need a G4Ions* <<
1635 // function, but GetIon returns a G4Particl <<
1636 auto base = static_cast<G4Ions const*>(GetI <<
1637 return GetMuonicAtom(base); <<
1638 } <<
1639 557