| 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 // 23 //
>> 24 // $Id: G4AtomicTransitionManager.cc,v 1.2 ????
>> 25 // GEANT4 tag $Name: geant4-04-00 $
27 // 26 //
28 // Authors: Elena Guardincerri (Elena.Guardinc 27 // Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
29 // Alfonso Mantero (Alfonso.Mantero@g 28 // Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
30 // 29 //
31 // History: 30 // History:
32 // ----------- 31 // -----------
33 // 16 Sep 2001 E. Guardincerri First Committe 32 // 16 Sep 2001 E. Guardincerri First Committed to cvs
34 // 33 //
35 // ------------------------------------------- 34 // -------------------------------------------------------------------
36 35
37 #include "G4AtomicTransitionManager.hh" 36 #include "G4AtomicTransitionManager.hh"
38 #include "G4EmParameters.hh" <<
39 #include "G4FluoData.hh" <<
40 #include "G4AugerData.hh" <<
41 #include "G4AutoLock.hh" <<
42 namespace { G4Mutex AtomicTransitionManagerMut <<
43 37
44 //....oooOO0OOooo........oooOO0OOooo........oo << 38 G4AtomicTransitionManager::G4AtomicTransitionManager(G4int minZ, G4int maxZ, G4int limitInfTable,G4int limitSupTable)
45 G4AtomicTransitionManager* G4AtomicTransitionM << 39 :zMin(minZ), zMax(maxZ),infTableLimit(limitInfTable),supTableLimit(limitSupTable)
46 <<
47 //....oooOO0OOooo........oooOO0OOooo........oo <<
48 G4AtomicTransitionManager* G4AtomicTransitionM <<
49 { 40 {
50 if (instance == nullptr) { << 41 // infTableLimit is initialized to 6 because EADL lacks data for Z<=5
51 instance = new G4AtomicTransitionManager() << 42 G4ShellData* shellManager = new G4ShellData;
52 } << 43
53 return instance; << 44 shellManager->LoadData("/fluor/binding");
>> 45
>> 46 // Fills shellTable with the data from EADL, identities and binding
>> 47 // energies of shells
>> 48 for (G4int Z = zMin; Z<= zMax; Z++)
>> 49 {
>> 50 G4std::vector<G4AtomicShell*> vectorOfShells;
>> 51
>> 52 size_t numberOfShells=shellManager->NumberOfShells(Z);
>> 53 for (size_t shellIndex = 0; shellIndex<numberOfShells; shellIndex++)
>> 54 {
>> 55 G4int shellId = shellManager->ShellId(Z,shellIndex);
>> 56 G4double bindingEnergy = shellManager->BindingEnergy(Z,shellIndex);
>> 57
>> 58 G4AtomicShell * shell = new G4AtomicShell(shellId,bindingEnergy);
>> 59
>> 60 vectorOfShells.push_back(shell);
>> 61 }
>> 62
>> 63 // shellTable.insert(G4std::make_pair(Z, vectorOfShells));
>> 64 shellTable[Z] = vectorOfShells;
>> 65 }
>> 66
>> 67 // Fills transitionTable with the data from EADL, identities, transition
>> 68 // energies and transition probabilities
>> 69 for (G4int Znum= infTableLimit; Znum<=supTableLimit; Znum++)
>> 70 { G4FluoData* fluoManager = new G4FluoData;
>> 71 G4std::vector<G4AtomicTransition*> vectorOfTransitions;
>> 72 fluoManager->LoadData(Znum);
>> 73
>> 74 size_t numberOfVacancies = fluoManager-> NumberOfVacancies();
>> 75
>> 76 for (size_t vacancyIndex = 0; vacancyIndex<numberOfVacancies; vacancyIndex++)
>> 77
>> 78 {
>> 79 G4std::vector<G4int> vectorOfIds;
>> 80 G4DataVector vectorOfEnergies;
>> 81 G4DataVector vectorOfProbabilities;
>> 82
>> 83 G4int finalShell = fluoManager->VacancyId(vacancyIndex);
>> 84 size_t numberOfTransitions = fluoManager->NumberOfTransitions(vacancyIndex);
>> 85 for (size_t origShellIndex = 0; origShellIndex <= numberOfTransitions;origShellIndex++)
>> 86
>> 87 {
>> 88
>> 89 G4int originatingShellId = fluoManager->StartShellId(origShellIndex,vacancyIndex);
>> 90
>> 91 vectorOfIds.push_back(originatingShellId);
>> 92
>> 93 G4double transitionEnergy = fluoManager->StartShellEnergy(origShellIndex,vacancyIndex);
>> 94 vectorOfEnergies.push_back(transitionEnergy);
>> 95 G4double transitionProbability = fluoManager->StartShellProb(origShellIndex,vacancyIndex);
>> 96 vectorOfProbabilities.push_back(transitionProbability);
>> 97 }
>> 98 G4AtomicTransition * transition = new G4AtomicTransition (finalShell,vectorOfIds,
>> 99 vectorOfEnergies,vectorOfProbabilities);
>> 100 vectorOfTransitions.push_back(transition);
>> 101 }
>> 102 // transitionTable.insert(G4std::make_pair(Znum, vectorOfTransitions));
>> 103 transitionTable[Znum] = vectorOfTransitions;
>> 104
>> 105 delete fluoManager;
>> 106 }
>> 107 delete shellManager;
54 } 108 }
55 109
56 //....oooOO0OOooo........oooOO0OOooo........oo <<
57 G4AtomicTransitionManager::G4AtomicTransitionM <<
58 : augerData(nullptr), <<
59 verboseLevel(0), <<
60 isInitialized(false) <<
61 {} <<
62 <<
63 //....oooOO0OOooo........oooOO0OOooo........oo <<
64 G4AtomicTransitionManager::~G4AtomicTransition 110 G4AtomicTransitionManager::~G4AtomicTransitionManager()
65 { << 111
66 delete augerData; << 112 { G4std::map<G4int,G4std::vector<G4AtomicShell*>,G4std::less<G4int> >::iterator pos;
67 113
68 for (auto& pos : shellTable){ << 114 for (pos = shellTable.begin(); pos != shellTable.end(); pos++){
69 std::vector<G4AtomicShell*>vec = pos.secon << 115
70 std::size_t vecSize = vec.size(); << 116 G4std::vector< G4AtomicShell*>vec = (*pos).second;
71 for (std::size_t i=0; i< vecSize; ++i){ << 117
72 G4AtomicShell* shell = vec[i]; << 118 G4int vecSize=vec.size();
73 delete shell; << 119
74 } << 120 for (G4int i=0; i< vecSize; i++){
75 } << 121
>> 122 delete vec[i];
>> 123 }
>> 124
>> 125 }
76 126
77 for (auto& ppos : transitionTable) << 127 G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> >::iterator ppos;
78 { << 128
79 std::vector<G4FluoTransition*>vec = ppos << 129 for (ppos = transitionTable.begin(); ppos != transitionTable.end(); ppos++){
80 std::size_t vecSize=vec.size(); <<
81 130
82 for (std::size_t i=0; i< vecSize; ++i){ << 131 G4std::vector< G4AtomicTransition*>vec = (*ppos).second;
83 G4FluoTransition* transition = vec[i]; << 132
84 delete transition; << 133 G4int vecSize=vec.size();
85 } << 134
86 } << 135 for (G4int i=0; i< vecSize; i++){
>> 136
>> 137 delete vec[i];
>> 138 }
>> 139
>> 140 }
>> 141
87 } 142 }
88 //....oooOO0OOooo........oooOO0OOooo........oo <<
89 G4AtomicShell* <<
90 G4AtomicTransitionManager::Shell(G4int Z, size <<
91 { <<
92 auto pos = shellTable.find(Z); <<
93 <<
94 if (pos!= shellTable.end()) <<
95 { <<
96 std::vector<G4AtomicShell*> v = (*pos).s <<
97 if (shellIndex < v.size()) { return v[sh <<
98 143
99 else << 144 G4AtomicTransitionManager* G4AtomicTransitionManager::instance = 0;
100 { << 145
101 size_t lastShell = v.size(); << 146 G4AtomicTransitionManager* G4AtomicTransitionManager::Instance()
102 G4ExceptionDescription ed; << 147 {
103 ed << "No de-excitation for Z= " << Z << 148 if (instance==0)
104 << " shellIndex= " << shellIndex <<
105 << ">= numberOfShells= " << lastShell; <<
106 if (verboseLevel > 0) <<
107 G4Exception("G4AtomicTransitionM <<
108 JustWarning,ed," AtomicShell not found"); <<
109 if (lastShell > 0) { return v[lastShell - <<
110 } <<
111 } <<
112 else <<
113 { 149 {
114 G4ExceptionDescription ed; << 150 instance = new G4AtomicTransitionManager;
115 ed << "No de-excitation for Z= " << Z << 151
116 << " shellIndex= " << shellIndex << 152 }
117 << ". AtomicShell not found - check if data << 153 return instance;
118 G4Exception("G4AtomicTransitionManager:: <<
119 FatalException,ed,""); <<
120 } <<
121 return 0; <<
122 } 154 }
123 155
124 //....oooOO0OOooo........oooOO0OOooo........oo <<
125 156
126 // This function gives, upon Z and the Index o << 157 const G4AtomicShell* G4AtomicTransitionManager::Shell(G4int Z, size_t shellIndex)
127 // the vacancy is, the radiative transition th << 158 {
128 // shell, energy, probability) << 159 G4std::map<G4int,G4std::vector<G4AtomicShell*>,G4std::less<G4int> >::iterator pos;
129 const G4FluoTransition* << 160
130 G4AtomicTransitionManager::ReachableShell(G4in << 161 pos = shellTable.find(Z);
>> 162
>> 163 if (pos!= shellTable.end()){
>> 164
>> 165 G4std::vector<G4AtomicShell*> v = (*pos).second;
>> 166
>> 167 if (shellIndex<v.size()){
>> 168
>> 169 return(v[shellIndex]);
>> 170
>> 171 }
>> 172 else {
>> 173 G4Exception("G4AtomicTransitionManager:shell not found");
>> 174 return 0;
>> 175 }
>> 176 }
>> 177 else{
>> 178 G4Exception("G4AtomicTransitionManager:Z not found");
>> 179 return 0;
>> 180 }
>> 181 }
>> 182
>> 183 const G4AtomicTransition* G4AtomicTransitionManager:: ReachableShell(G4int Z,size_t shellIndex)
131 { 184 {
132 auto pos = transitionTable.find(Z); << 185 G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> >::iterator pos;
>> 186 pos = transitionTable.find(Z);
133 if (pos!= transitionTable.end()) 187 if (pos!= transitionTable.end())
134 { 188 {
135 std::vector<G4FluoTransition*> v = (*pos << 189 G4std::vector<G4AtomicTransition*> v = (*pos).second;
136 if (shellIndex < v.size()) { return(v[sh << 190 if (shellIndex < v.size()) return(v[shellIndex]);
137 <<
138 else { 191 else {
139 G4ExceptionDescription ed; << 192 G4Exception("G4AtomicTransitionManager:reachable shell not found");
140 ed << "No fluo transition for Z= " << Z << 193 return 0;
141 << " shellIndex= " << shellIndex; <<
142 G4Exception("G4AtomicTransitionManager::Reac <<
143 FatalException,ed,""); <<
144 } 194 }
145 } << 195 }
146 else << 196 else{
147 { << 197 G4Exception("G4AtomicTransitionManager:Z not found");
148 G4ExceptionDescription ed; << 198 return 0;
149 ed << "No transition table for Z= " << Z << 199 }
150 << " shellIndex= " << shellIndex; <<
151 G4Exception("G4AtomicTransitionManager:: <<
152 FatalException,ed,""); <<
153 } <<
154 return 0; <<
155 } 200 }
156 201
157 //....oooOO0OOooo........oooOO0OOooo........oo << 202 G4int G4AtomicTransitionManager::NumberOfShells (G4int Z)
158 const G4AugerTransition* <<
159 G4AtomicTransitionManager::ReachableAugerShell <<
160 G4int vacancyShellIndex) cons <<
161 { 203 {
162 return augerData->GetAugerTransition(Z,vacan <<
163 } <<
164 204
165 //....oooOO0OOooo........oooOO0OOooo........oo << 205 G4std::map<G4int,G4std::vector<G4AtomicShell*>,G4std::less<G4int> >::iterator pos;
166 G4int G4AtomicTransitionManager::NumberOfShell << 206
167 { << 207 pos = shellTable.find(Z);
168 auto pos = shellTable.find(Z); <<
169 208
170 std::size_t res = 0; << 209 if (pos!= shellTable.end()){
171 if (pos != shellTable.cend()){ <<
172 210
173 res = ((*pos).second).size(); << 211 G4std::vector<G4AtomicShell*> v = (*pos).second;
>> 212
>> 213 return v.size();
>> 214 }
174 215
175 } else { << 216 else{
176 G4ExceptionDescription ed; << 217 G4Exception( "G4AtomicTransitionManager: Z not found" );
177 ed << "No deexcitation for Z= " << Z; << 218 return 0;
178 G4Exception("G4AtomicTransitionManager::Nu <<
179 FatalException, ed, ""); <<
180 } 219 }
181 return (G4int)res; <<
182 } 220 }
183 221
184 //....oooOO0OOooo........oooOO0OOooo........oo << 222 G4int G4AtomicTransitionManager::NumberOfReachableShells(G4int Z)
185 // This function returns the number of possibl <<
186 // the atom with atomic number Z i.e. the numb <<
187 // can be filled with a radiative transition <<
188 G4int G4AtomicTransitionManager::NumberOfReach <<
189 { 223 {
190 auto pos = transitionTable.find(Z); << 224 G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> >::iterator pos;
191 std::size_t res = 0; << 225
192 if (pos!= transitionTable.cend()) << 226 pos = transitionTable.find(Z);
>> 227
>> 228 if (pos!= transitionTable.end())
193 { 229 {
194 res = ((*pos).second).size(); << 230 G4std::vector<G4AtomicTransition*> v = (*pos).second;
>> 231 return v.size();
195 } 232 }
196 else 233 else
197 { 234 {
198 G4ExceptionDescription ed; << 235 G4Exception( "G4AtomicTransitionManager: Z not found" );
199 ed << "No deexcitation for Z= " << Z << 236 return 0;
200 << ", so energy deposited locally"; <<
201 G4Exception("G4AtomicTransitionManager:: <<
202 "de0001",FatalException,ed,""); <<
203 } 237 }
204 return (G4int)res; <<
205 } 238 }
206 239
207 //....oooOO0OOooo........oooOO0OOooo........oo << 240 G4double G4AtomicTransitionManager::TotalRadiativeTransitionProbability(G4int Z,
208 // This function returns the number of possibl << 241 size_t shellIndex)
209 // for the atom with atomic number Z i.e. the <<
210 // vacancy can be filled with a NON-radiative <<
211 G4int G4AtomicTransitionManager::NumberOfReach <<
212 { <<
213 return (G4int)augerData->NumberOfVacancies(Z <<
214 } <<
215 242
216 //....oooOO0OOooo........oooOO0OOooo........oo <<
217 G4double G4AtomicTransitionManager::TotalRadia <<
218 G4int Z, size_t shellIndex) const <<
219 { 243 {
220 auto pos = transitionTable.find(Z); << 244 G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> >::iterator pos;
221 G4double totalRadTransProb = 0.0; << 245
>> 246 pos = transitionTable.find(Z);
222 247
223 if (pos!= transitionTable.end()) 248 if (pos!= transitionTable.end())
224 { 249 {
225 std::vector<G4FluoTransition*> v = (*pos << 250 G4std::vector<G4AtomicTransition*> v = (*pos).second;
226 251
227 if (shellIndex < v.size()) << 252 if (shellIndex < v.size())
228 { << 253 {
229 G4FluoTransition* transition = v[shellInde << 254 G4AtomicTransition* transition = v[shellIndex];
230 G4DataVector transProb = transition->Trans << 255 G4DataVector transProb = transition->TransitionProbabilities();
>> 256 G4double totalRadTransProb = 0;
231 257
232 for (size_t j=0; j<transProb.size(); ++j) << 258 for (size_t j = 1; j<transProb.size(); j++)
233 { <<
234 totalRadTransProb += transProb[j]; <<
235 } <<
236 } <<
237 else <<
238 { 259 {
239 G4ExceptionDescription ed; << 260 totalRadTransProb = totalRadTransProb + transProb[j];
240 ed << "Zero transition probability for Z=" <<
241 << " shellIndex= " << shellIndex; <<
242 G4Exception( <<
243 "G4AtomicTransitionManager::TotalRadiative <<
244 "de0002",FatalException,"Incorrect de-exci <<
245 } 261 }
>> 262 return totalRadTransProb;
>> 263
>> 264 }
>> 265 else {
>> 266 G4Exception( "G4AtomicTransitionManager: shell not found" );
>> 267 return 0;
>> 268
246 } 269 }
247 else <<
248 { <<
249 G4ExceptionDescription ed; <<
250 ed << "No deexcitation for Z=" << Z <<
251 << " shellIndex= " << shellIndex; <<
252 G4Exception( <<
253 "G4AtomicTransitionManager::TotalRadiati <<
254 "de0001",FatalException,ed,"Cannot compu <<
255 } <<
256 return totalRadTransProb; <<
257 } <<
258 <<
259 //....oooOO0OOooo........oooOO0OOooo........oo <<
260 G4double G4AtomicTransitionManager::TotalNonRa <<
261 G4int Z, size_t shellIndex) c <<
262 { <<
263 G4double prob = 1.0 - TotalRadiativeTransiti <<
264 if(prob > 1.0 || prob < 0.0) { <<
265 G4ExceptionDescription ed; <<
266 ed << "Total probability mismatch Z= " << <<
267 << " shellIndex= " << shellIndex <<
268 << " prob= " << prob; <<
269 G4Exception( <<
270 "G4AtomicTransitionManager::TotalNonRadiat <<
271 "de0003",FatalException,ed,"Cannot compute <<
272 return 0.0; <<
273 } 270 }
274 return prob; << 271 else{
>> 272 G4Exception( "G4AtomicTransitionManager: Z not found");
>> 273 return 0;
>> 274 }
275 } 275 }
276 276
277 //....oooOO0OOooo........oooOO0OOooo........oo << 277 G4double G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability(G4int Z, size_t shellIndex)
278 void G4AtomicTransitionManager::Initialise() <<
279 { <<
280 if(isInitialized) { return; } <<
281 G4AutoLock l(&AtomicTransitionManagerMutex); <<
282 278
283 if(isInitialized) { return; } << 279 {
284 isInitialized = true; <<
285 280
286 // Selection of fluorescence files << 281 G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> >::iterator pos;
287 282
288 const G4String& defaultDirectory = "/fluor"; << 283 pos = transitionTable.find(Z);
289 G4String fluoDirectory = defaultDirectory; <<
290 G4String bindingDirectory = defaultDirectory <<
291 G4EmFluoDirectory fdir = G4EmParameters::Ins <<
292 G4int zLim = zMax + 1; <<
293 if(fdir == fluoBearden) { <<
294 zMax = 100; <<
295 supTableLimit = 100; <<
296 bindingDirectory = fluoDirectory = "/fluor <<
297 } else if(fdir == fluoANSTO) { <<
298 zLim = 93; <<
299 fluoDirectory = "/fluor_ANSTO"; <<
300 } else if(fdir == fluoXDB_EADL) { <<
301 zMax = 100; <<
302 supTableLimit = 100; <<
303 bindingDirectory = fluoDirectory = "/fluor <<
304 } <<
305 <<
306 // infTableLimit is initialized to 6 because <<
307 G4ShellData* shellManager = new G4ShellData( <<
308 shellManager->LoadData(bindingDirectory + "/ <<
309 <<
310 // initialization of the data for auger effe <<
311 augerData = new G4AugerData; <<
312 284
313 // Fills shellTable with the data from EADL, << 285 if (pos!= transitionTable.end()){
314 // energies of shells << 286
315 for (G4int Z = zMin; Z <= zMax; ++Z) << 287 G4std::vector<G4AtomicTransition*> v = (*pos).second;
316 { <<
317 std::vector<G4AtomicShell*> vectorOfShel <<
318 G4int shellIndex = 0; <<
319 <<
320 G4int numberOfShells = (G4int)shellManag <<
321 for (shellIndex = 0; shellIndex<numberOf <<
322 { <<
323 G4int shellId = shellManager->ShellId(Z,sh <<
324 G4double bindingEnergy = shellManager->Bin <<
325 G4AtomicShell * shell = new G4AtomicShell( <<
326 vectorOfShells.push_back(shell); <<
327 } <<
328 shellTable[Z] = std::move(vectorOfShells <<
329 } <<
330 288
331 // Fills transitionTable with the data on id <<
332 // energies and transition probabilities <<
333 G4String dir = std::move(fluoDirectory); <<
334 for (G4int Znum= infTableLimit; Znum<=supTab <<
335 { <<
336 if (Znum == zLim) { dir = defaultDirecto <<
337 G4FluoData* fluoManager = new G4FluoData <<
338 std::vector<G4FluoTransition*> vectorOfT <<
339 fluoManager->LoadData(Znum); <<
340 289
341 G4int numberOfVacancies = (G4int)fluoMan << 290 if (shellIndex<v.size()){
342 for(G4int vacancyIndex = 0; vacancyIndex << 291
343 ++vacancyIndex) << 292 G4AtomicTransition* transition=v[shellIndex];
>> 293 G4DataVector transProb = transition->TransitionProbabilities();
>> 294 G4double totalRadTransProb = 0;
>> 295
>> 296 for(size_t j = 1; j<transProb.size(); j++)
344 { 297 {
345 std::vector<G4int> vectorOfIds; << 298 totalRadTransProb = totalRadTransProb + transProb[j];
346 G4DataVector vectorOfEnergies; <<
347 G4DataVector vectorOfProbabilities; <<
348 <<
349 G4int finalShell = fluoManager->VacancyId( <<
350 G4int numberOfTransitions = (G4int) <<
351 fluoManager->NumberOfTransitio <<
352 for (G4int origShellIndex = 0; origShellIn <<
353 ++origShellIndex) <<
354 { <<
355 G4int originatingShellId = <<
356 fluoManager->StartShellId(origShellIndex,v <<
357 vectorOfIds.push_back(originatingShell <<
358 <<
359 G4double transitionEnergy = <<
360 fluoManager->StartShellEnergy(origShellInd <<
361 vectorOfEnergies.push_back(transitionE <<
362 G4double transitionProbability = <<
363 fluoManager->StartShellProb(origShellIndex <<
364 vectorOfProbabilities.push_back(transi <<
365 } <<
366 G4FluoTransition* transition = <<
367 new G4FluoTransition (finalShell,vectorO <<
368 vectorOfEnergies,vectorOfProbabiliti <<
369 vectorOfTransitions.push_back(transition); <<
370 } 299 }
371 transitionTable[Znum] = std::move(vector << 300
372 delete fluoManager; << 301 G4double totalNonRadTransProb= (1 - totalRadTransProb);
>> 302
>> 303 return totalNonRadTransProb; }
>> 304
>> 305 else {
>> 306 G4Exception( "shell not found");
>> 307 return 0;
373 } 308 }
374 delete shellManager; << 309 }
375 l.unlock(); << 310 else{
>> 311 G4Exception("Z not found");
>> 312 return 0;
>> 313 }
376 } 314 }
>> 315
>> 316
>> 317
>> 318
>> 319
>> 320
>> 321
>> 322
>> 323
>> 324
377 325