| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id: G4AtomicTransitionManager.cc,v 1.2 ????
>> 28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
27 // 29 //
28 // Authors: Elena Guardincerri (Elena.Guardinc 30 // Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
29 // Alfonso Mantero (Alfonso.Mantero@g 31 // Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
30 // 32 //
31 // History: 33 // History:
32 // ----------- 34 // -----------
33 // 16 Sep 2001 E. Guardincerri First Committe 35 // 16 Sep 2001 E. Guardincerri First Committed to cvs
34 // 36 //
35 // ------------------------------------------- 37 // -------------------------------------------------------------------
36 38
37 #include "G4AtomicTransitionManager.hh" 39 #include "G4AtomicTransitionManager.hh"
38 #include "G4EmParameters.hh" <<
39 #include "G4FluoData.hh" <<
40 #include "G4AugerData.hh" <<
41 #include "G4AutoLock.hh" <<
42 namespace { G4Mutex AtomicTransitionManagerMut <<
43 40
44 //....oooOO0OOooo........oooOO0OOooo........oo << 41 G4AtomicTransitionManager::G4AtomicTransitionManager(G4int minZ, G4int maxZ,
45 G4AtomicTransitionManager* G4AtomicTransitionM << 42 G4int limitInfTable,G4int limitSupTable)
46 << 43 :zMin(minZ),
47 //....oooOO0OOooo........oooOO0OOooo........oo << 44 zMax(maxZ),
48 G4AtomicTransitionManager* G4AtomicTransitionM << 45 infTableLimit(limitInfTable),
>> 46 supTableLimit(limitSupTable)
49 { 47 {
50 if (instance == nullptr) { << 48 // infTableLimit is initialized to 6 because EADL lacks data for Z<=5
51 instance = new G4AtomicTransitionManager() << 49 G4ShellData* shellManager = new G4ShellData;
52 } <<
53 return instance; <<
54 } <<
55 50
56 //....oooOO0OOooo........oooOO0OOooo........oo << 51 // initialization of the data for auger effect
57 G4AtomicTransitionManager::G4AtomicTransitionM << 52
58 : augerData(nullptr), << 53 augerData = new G4AugerData;
59 verboseLevel(0), << 54
60 isInitialized(false) << 55 shellManager->LoadData("/fluor/binding");
61 {} << 56
>> 57 // Fills shellTable with the data from EADL, identities and binding
>> 58 // energies of shells
>> 59 for (G4int Z = zMin; Z<= zMax; Z++)
>> 60 {
>> 61 std::vector<G4AtomicShell*> vectorOfShells;
>> 62
>> 63 size_t numberOfShells=shellManager->NumberOfShells(Z);
>> 64 for (size_t shellIndex = 0; shellIndex<numberOfShells; shellIndex++)
>> 65 {
>> 66 G4int shellId = shellManager->ShellId(Z,shellIndex);
>> 67 G4double bindingEnergy = shellManager->BindingEnergy(Z,shellIndex);
>> 68
>> 69 G4AtomicShell * shell = new G4AtomicShell(shellId,bindingEnergy);
>> 70
>> 71 vectorOfShells.push_back(shell);
>> 72 }
>> 73
>> 74 // shellTable.insert(std::make_pair(Z, vectorOfShells));
>> 75 shellTable[Z] = vectorOfShells;
>> 76 }
>> 77
>> 78 // Fills transitionTable with the data from EADL, identities, transition
>> 79 // energies and transition probabilities
>> 80 for (G4int Znum= infTableLimit; Znum<=supTableLimit; Znum++)
>> 81 { G4FluoData* fluoManager = new G4FluoData;
>> 82 std::vector<G4FluoTransition*> vectorOfTransitions;
>> 83 fluoManager->LoadData(Znum);
>> 84
>> 85 size_t numberOfVacancies = fluoManager-> NumberOfVacancies();
>> 86
>> 87 for (size_t vacancyIndex = 0; vacancyIndex<numberOfVacancies; vacancyIndex++)
>> 88
>> 89 {
>> 90 std::vector<G4int> vectorOfIds;
>> 91 G4DataVector vectorOfEnergies;
>> 92 G4DataVector vectorOfProbabilities;
>> 93
>> 94 G4int finalShell = fluoManager->VacancyId(vacancyIndex);
>> 95 size_t numberOfTransitions = fluoManager->NumberOfTransitions(vacancyIndex);
>> 96 for (size_t origShellIndex = 0; origShellIndex < numberOfTransitions;
>> 97 origShellIndex++)
>> 98
>> 99 {
>> 100
>> 101 G4int originatingShellId = fluoManager->StartShellId(origShellIndex,vacancyIndex);
>> 102
>> 103 vectorOfIds.push_back(originatingShellId);
>> 104
>> 105 G4double transitionEnergy = fluoManager->StartShellEnergy(origShellIndex,vacancyIndex);
>> 106 vectorOfEnergies.push_back(transitionEnergy);
>> 107 G4double transitionProbability = fluoManager->StartShellProb(origShellIndex,vacancyIndex);
>> 108 vectorOfProbabilities.push_back(transitionProbability);
>> 109 }
>> 110 G4FluoTransition * transition = new G4FluoTransition (finalShell,vectorOfIds,
>> 111 vectorOfEnergies,vectorOfProbabilities);
>> 112 vectorOfTransitions.push_back(transition);
>> 113 }
>> 114 // transitionTable.insert(std::make_pair(Znum, vectorOfTransitions));
>> 115 transitionTable[Znum] = vectorOfTransitions;
>> 116
>> 117 delete fluoManager;
>> 118 }
>> 119 delete shellManager;
>> 120 }
62 121
63 //....oooOO0OOooo........oooOO0OOooo........oo <<
64 G4AtomicTransitionManager::~G4AtomicTransition 122 G4AtomicTransitionManager::~G4AtomicTransitionManager()
>> 123
65 { 124 {
>> 125
66 delete augerData; 126 delete augerData;
>> 127
>> 128 std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::iterator pos;
67 129
68 for (auto& pos : shellTable){ << 130 for (pos = shellTable.begin(); pos != shellTable.end(); pos++){
69 std::vector<G4AtomicShell*>vec = pos.secon << 131
70 std::size_t vecSize = vec.size(); << 132 std::vector< G4AtomicShell*>vec = (*pos).second;
71 for (std::size_t i=0; i< vecSize; ++i){ << 133
72 G4AtomicShell* shell = vec[i]; << 134 G4int vecSize=vec.size();
73 delete shell; << 135
74 } << 136 for (G4int i=0; i< vecSize; i++){
75 } << 137 G4AtomicShell* shell = vec[i];
>> 138 delete shell;
>> 139 }
>> 140
>> 141 }
76 142
77 for (auto& ppos : transitionTable) << 143 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::iterator ppos;
78 { << 144
79 std::vector<G4FluoTransition*>vec = ppos << 145 for (ppos = transitionTable.begin(); ppos != transitionTable.end(); ppos++){
80 std::size_t vecSize=vec.size(); <<
81 146
82 for (std::size_t i=0; i< vecSize; ++i){ << 147 std::vector<G4FluoTransition*>vec = (*ppos).second;
83 G4FluoTransition* transition = vec[i]; << 148
84 delete transition; << 149 G4int vecSize=vec.size();
85 } << 150
86 } << 151 for (G4int i=0; i< vecSize; i++){
>> 152 G4FluoTransition* transition = vec[i];
>> 153 delete transition;
>> 154 }
>> 155
>> 156 }
>> 157
87 } 158 }
88 //....oooOO0OOooo........oooOO0OOooo........oo << 159
89 G4AtomicShell* << 160 G4AtomicTransitionManager* G4AtomicTransitionManager::instance = 0;
90 G4AtomicTransitionManager::Shell(G4int Z, size << 161
91 { << 162 G4AtomicTransitionManager* G4AtomicTransitionManager::Instance()
92 auto pos = shellTable.find(Z); << 163 {
>> 164 if (instance == 0)
>> 165 {
>> 166 instance = new G4AtomicTransitionManager;
>> 167
>> 168 }
>> 169 return instance;
>> 170 }
>> 171
>> 172
>> 173 G4AtomicShell* G4AtomicTransitionManager::Shell(G4int Z, size_t shellIndex) const
>> 174 {
>> 175 std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::const_iterator pos;
>> 176
>> 177 pos = shellTable.find(Z);
93 178
94 if (pos!= shellTable.end()) 179 if (pos!= shellTable.end())
95 { 180 {
96 std::vector<G4AtomicShell*> v = (*pos).s 181 std::vector<G4AtomicShell*> v = (*pos).second;
97 if (shellIndex < v.size()) { return v[sh << 182 if (shellIndex<v.size())
98 << 183 {
>> 184 return(v[shellIndex]);
>> 185 }
99 else 186 else
100 { 187 {
101 size_t lastShell = v.size(); 188 size_t lastShell = v.size();
102 G4ExceptionDescription ed; << 189 G4cout << "G4AtomicTransitionManager::Shell - Z = "
103 ed << "No de-excitation for Z= " << Z << 190 << Z << ", shellIndex = " << shellIndex
104 << " shellIndex= " << shellIndex << 191 << " not found; number of shells = " << lastShell << G4endl;
105 << ">= numberOfShells= " << lastShell; << 192 // G4Exception("G4AtomicTransitionManager:shell not found");
106 if (verboseLevel > 0) << 193 if (lastShell > 0)
107 G4Exception("G4AtomicTransitionM << 194 {
108 JustWarning,ed," AtomicShell not found"); << 195 return v[lastShell - 1];
109 if (lastShell > 0) { return v[lastShell - << 196 }
>> 197 else
>> 198 {
>> 199 return 0;
>> 200 }
110 } 201 }
111 } 202 }
112 else 203 else
113 { 204 {
114 G4ExceptionDescription ed; << 205 G4Exception("G4AtomicTransitionManager:Z not found");
115 ed << "No de-excitation for Z= " << Z << 206 return 0;
116 << " shellIndex= " << shellIndex <<
117 << ". AtomicShell not found - check if data <<
118 G4Exception("G4AtomicTransitionManager:: <<
119 FatalException,ed,""); <<
120 } 207 }
121 return 0; <<
122 } 208 }
123 209
124 //....oooOO0OOooo........oooOO0OOooo........oo << 210 // This function gives, upon Z and the Index of the initial shell where te vacancy is,
>> 211 // the radiative transition that can happen (originating shell, energy, probability)
125 212
126 // This function gives, upon Z and the Index o << 213 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 { 214 {
132 auto pos = transitionTable.find(Z); << 215 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::const_iterator pos;
>> 216 pos = transitionTable.find(Z);
133 if (pos!= transitionTable.end()) 217 if (pos!= transitionTable.end())
134 { 218 {
135 std::vector<G4FluoTransition*> v = (*pos 219 std::vector<G4FluoTransition*> v = (*pos).second;
136 if (shellIndex < v.size()) { return(v[sh << 220 if (shellIndex < v.size()) return(v[shellIndex]);
137 <<
138 else { 221 else {
139 G4ExceptionDescription ed; << 222 G4Exception("G4AtomicTransitionManager:reachable shell not found");
140 ed << "No fluo transition for Z= " << Z << 223 return 0;
141 << " shellIndex= " << shellIndex; <<
142 G4Exception("G4AtomicTransitionManager::Reac <<
143 FatalException,ed,""); <<
144 } 224 }
145 } << 225 }
146 else << 226 else{
147 { << 227 G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
148 G4ExceptionDescription ed; << 228 G4cout << "Absorbed enrgy deposited locally" << G4endl;
149 ed << "No transition table for Z= " << Z << 229
150 << " shellIndex= " << shellIndex; << 230 // G4Exception("G4AtomicTransitionManager:Z not found");
151 G4Exception("G4AtomicTransitionManager:: << 231 return 0;
152 FatalException,ed,""); << 232 }
153 } <<
154 return 0; <<
155 } 233 }
156 234
157 //....oooOO0OOooo........oooOO0OOooo........oo << 235 const G4AugerTransition* G4AtomicTransitionManager::ReachableAugerShell(G4int Z, G4int vacancyShellIndex) const
158 const G4AugerTransition* <<
159 G4AtomicTransitionManager::ReachableAugerShell <<
160 G4int vacancyShellIndex) cons <<
161 { 236 {
162 return augerData->GetAugerTransition(Z,vacan << 237
>> 238 G4AugerTransition* augerTransition = augerData->GetAugerTransition(Z,vacancyShellIndex);
>> 239 return augerTransition;
163 } 240 }
164 241
165 //....oooOO0OOooo........oooOO0OOooo........oo << 242
>> 243
166 G4int G4AtomicTransitionManager::NumberOfShell 244 G4int G4AtomicTransitionManager::NumberOfShells (G4int Z) const
167 { 245 {
168 auto pos = shellTable.find(Z); <<
169 246
170 std::size_t res = 0; << 247 std::map<G4int,std::vector<G4AtomicShell*>,std::less<G4int> >::const_iterator pos;
171 if (pos != shellTable.cend()){ <<
172 248
173 res = ((*pos).second).size(); << 249 pos = shellTable.find(Z);
174 250
175 } else { << 251 if (pos!= shellTable.end()){
176 G4ExceptionDescription ed; << 252
177 ed << "No deexcitation for Z= " << Z; << 253 std::vector<G4AtomicShell*> v = (*pos).second;
178 G4Exception("G4AtomicTransitionManager::Nu << 254
179 FatalException, ed, ""); << 255 return v.size();
>> 256 }
>> 257
>> 258 else{
>> 259 G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
>> 260 G4cout << "Absorbed enrgy deposited locally" << G4endl;
>> 261
>> 262 // G4Exception("G4AtomicTransitionManager:Z not found");
>> 263 return 0;
180 } 264 }
181 return (G4int)res; <<
182 } 265 }
183 266
184 //....oooOO0OOooo........oooOO0OOooo........oo << 267 // This function returns the number of possible radiative transitions for the atom with atomic number Z
185 // This function returns the number of possibl << 268 // 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 << 269
187 // can be filled with a radiative transition <<
188 G4int G4AtomicTransitionManager::NumberOfReach 270 G4int G4AtomicTransitionManager::NumberOfReachableShells(G4int Z) const
189 { 271 {
190 auto pos = transitionTable.find(Z); << 272 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::const_iterator pos;
191 std::size_t res = 0; << 273
192 if (pos!= transitionTable.cend()) << 274 pos = transitionTable.find(Z);
>> 275
>> 276 if (pos!= transitionTable.end())
193 { 277 {
194 res = ((*pos).second).size(); << 278 std::vector<G4FluoTransition*> v = (*pos).second;
>> 279 return v.size();
195 } 280 }
196 else 281 else
197 { 282 {
198 G4ExceptionDescription ed; << 283 G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
199 ed << "No deexcitation for Z= " << Z << 284 G4cout << "Absorbed enrgy deposited locally" << G4endl;
200 << ", so energy deposited locally"; << 285
201 G4Exception("G4AtomicTransitionManager:: << 286 // G4Exception("G4AtomicTransitionManager:Z not found");
202 "de0001",FatalException,ed,""); << 287 return 0;
203 } 288 }
204 return (G4int)res; <<
205 } 289 }
206 290
207 //....oooOO0OOooo........oooOO0OOooo........oo << 291 // 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 << 292 // 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 << 293
210 // vacancy can be filled with a NON-radiative <<
211 G4int G4AtomicTransitionManager::NumberOfReach 294 G4int G4AtomicTransitionManager::NumberOfReachableAugerShells(G4int Z)const
212 { 295 {
213 return (G4int)augerData->NumberOfVacancies(Z << 296 G4int n = augerData->NumberOfVacancies(Z);
>> 297 return n;
214 } 298 }
215 299
216 //....oooOO0OOooo........oooOO0OOooo........oo << 300
217 G4double G4AtomicTransitionManager::TotalRadia << 301
218 G4int Z, size_t shellIndex) const << 302 G4double G4AtomicTransitionManager::TotalRadiativeTransitionProbability(G4int Z,
>> 303 size_t shellIndex)
>> 304
219 { 305 {
220 auto pos = transitionTable.find(Z); << 306 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::iterator pos;
221 G4double totalRadTransProb = 0.0; << 307
>> 308 pos = transitionTable.find(Z);
222 309
223 if (pos!= transitionTable.end()) 310 if (pos!= transitionTable.end())
224 { 311 {
225 std::vector<G4FluoTransition*> v = (*pos 312 std::vector<G4FluoTransition*> v = (*pos).second;
226 313
227 if (shellIndex < v.size()) << 314 if (shellIndex < v.size())
228 { << 315 {
229 G4FluoTransition* transition = v[shellInde << 316 G4FluoTransition* transition = v[shellIndex];
230 G4DataVector transProb = transition->Trans << 317 G4DataVector transProb = transition->TransitionProbabilities();
>> 318 G4double totalRadTransProb = 0;
231 319
232 for (size_t j=0; j<transProb.size(); ++j) << 320 for (size_t j = 1; j<transProb.size(); j++)
233 { <<
234 totalRadTransProb += transProb[j]; <<
235 } <<
236 } <<
237 else <<
238 { 321 {
239 G4ExceptionDescription ed; << 322 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 } 323 }
>> 324 return totalRadTransProb;
>> 325
>> 326 }
>> 327 else {
>> 328 G4Exception( "G4AtomicTransitionManager: shell not found" );
>> 329 return 0;
>> 330
246 } 331 }
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 } 332 }
274 return prob; << 333 else{
>> 334 G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
>> 335 G4cout << "Absorbed enrgy deposited locally" << G4endl;
>> 336
>> 337 // G4Exception("G4AtomicTransitionManager:Z not found");
>> 338
>> 339 return 0;
>> 340 }
275 } 341 }
276 342
277 //....oooOO0OOooo........oooOO0OOooo........oo << 343 G4double G4AtomicTransitionManager::TotalNonRadiativeTransitionProbability(G4int Z, size_t shellIndex)
278 void G4AtomicTransitionManager::Initialise() <<
279 { <<
280 if(isInitialized) { return; } <<
281 G4AutoLock l(&AtomicTransitionManagerMutex); <<
282 344
283 if(isInitialized) { return; } << 345 {
284 isInitialized = true; <<
285 346
286 // Selection of fluorescence files << 347 std::map<G4int,std::vector<G4FluoTransition*>,std::less<G4int> >::iterator pos;
287 348
288 const G4String& defaultDirectory = "/fluor"; << 349 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 350
313 // Fills shellTable with the data from EADL, << 351 if (pos!= transitionTable.end()){
314 // energies of shells << 352
315 for (G4int Z = zMin; Z <= zMax; ++Z) << 353 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 354
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 355
341 G4int numberOfVacancies = (G4int)fluoMan << 356 if (shellIndex<v.size()){
342 for(G4int vacancyIndex = 0; vacancyIndex << 357
343 ++vacancyIndex) << 358 G4FluoTransition* transition=v[shellIndex];
>> 359 G4DataVector transProb = transition->TransitionProbabilities();
>> 360 G4double totalRadTransProb = 0;
>> 361
>> 362 for(size_t j = 1; j<transProb.size(); j++)
344 { 363 {
345 std::vector<G4int> vectorOfIds; << 364 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 } 365 }
371 transitionTable[Znum] = std::move(vector << 366
372 delete fluoManager; << 367 G4double totalNonRadTransProb= (1 - totalRadTransProb);
>> 368
>> 369 return totalNonRadTransProb; }
>> 370
>> 371 else {
>> 372 G4Exception( "shell not found");
>> 373 return 0;
373 } 374 }
374 delete shellManager; << 375 }
375 l.unlock(); << 376 else{
>> 377 G4cout << "G4AtomicTransitionMagare warning: No fluorescence or Auger for Z=" << Z << G4endl;
>> 378 G4cout << "Absorbed enrgy deposited locally" << G4endl;
>> 379
>> 380 // G4Exception("G4AtomicTransitionManager:Z not found");
>> 381 return 0;
>> 382 }
376 } 383 }
>> 384
>> 385
>> 386
>> 387
>> 388
>> 389
>> 390
>> 391
>> 392
>> 393
377 394