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