| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 //
29 // Author: Alfonso Mmantero (Alfonso.Mantero@g
30 //
31 // History:
32 // -----------
33 // Based on G4RDFluoData by Elena Guardincerri
34 //
35 // Modified: 30.07.02 VI Add select active Z +
36 //
37 // -------------------------------------------
38
39 #include <fstream>
40 #include <sstream>
41
42 #include "G4RDAugerData.hh"
43 #include "G4PhysicalConstants.hh"
44 #include "G4SystemOfUnits.hh"
45 #include "G4DataVector.hh"
46 #include "G4Material.hh"
47 #include "G4Element.hh"
48 #include "G4ElementVector.hh"
49
50 G4RDAugerData::G4RDAugerData()
51 {
52
53 G4int n = 0;
54 G4int pos = 0;
55
56 for (pos = 0 ; pos < 100; pos++)
57 {
58 numberOfVacancies.push_back(n);
59 }
60
61 BuildAugerTransitionTable();
62
63
64 }
65
66 G4RDAugerData::~G4RDAugerData()
67 {
68 /*
69 std::map<G4int,std::vector<G4RDAugerTransiti
70
71 for (pos = augerTransitionTable.begin(); pos
72 {
73 std::vector<G4RDAugerTransition> dataSet
74 delete dataSet;
75 }
76 for (pos = energyMap.begin(); pos != energyM
77 {
78 std::map<G4Int,G4DataVector*,std::less<G
79 for (pos2 = newIdProbabilityMap.begin();
80 {
81 G4DataVector* dataSet = (*pos2).second;
82 delete dataSet;
83 }
84 }
85 for (pos = probabilityMap.begin(); pos != pr
86 {
87 std::map<G4Int,G4DataVector*,std::less<G
88 for (pos2 = newIdProbabilityMap.begin();
89 {
90 G4DataVector* dataSet = (*pos2).second;
91 delete dataSet;
92 }
93 }
94 for (pos2 = newIdMap.begin(); pos2 != idMap.
95 {
96 G4DataVector* dataSet = (*pos2).second;
97 delete dataSet;
98 }
99 for (pos2 = newIdEnergyMap.begin(); pos2 !=
100 {
101 G4DataVector* dataSet = (*pos2).second;
102 delete dataSet;
103 }
104 for (pos2 = newIdProbabilityMap.begin(); pos
105 {
106 G4DataVector* dataSet = (*pos2).second;
107 delete dataSet;
108 }
109 */
110
111 }
112
113 size_t G4RDAugerData::NumberOfVacancies(G4int
114 {
115 return numberOfVacancies[Z];
116 }
117
118 G4int G4RDAugerData::VacancyId(G4int Z, G4int
119 {
120
121 G4int n = 0;
122 if (vacancyIndex<0 || vacancyIndex>=numberOf
123 {G4Exception("G4RDAugerData::VacancyId()",
124 FatalException, "VacancyIndex
125 else {
126 trans_Table::const_iterator element = auge
127 if (element == augerTransitionTable.end())
128 {G4Exception("G4RDAugerData::VacancyId()
129 FatalException, "Data not l
130 std::vector<G4RDAugerTransition> dataSet =
131 n = (G4int) dataSet[vacancyIndex].FinalShe
132 }
133
134 return n;
135 }
136
137
138
139 // Attenzione: questa funzione vuole l'indice
140
141
142 size_t G4RDAugerData::NumberOfTransitions(G4in
143 {
144 G4int n = 0;
145 if (vacancyIndex<0 || vacancyIndex>=numberOf
146 {G4Exception("G4RDAugerData::NumberOfTrans
147 FatalException, "VacancyIndex
148 else {
149 trans_Table::const_iterator element = auge
150 if (element == augerTransitionTable.end())
151 {G4Exception("G4RDAugerData::NumberOfTra
152 FatalException, "Data not l
153 std::vector<G4RDAugerTransition> dataSet =
154 n = (G4int)dataSet[vacancyIndex].Transitio
155 }
156 return n;
157 }
158
159
160
161 size_t G4RDAugerData::NumberOfAuger(G4int Z, G
162 {
163 size_t n = 0;
164 if (initIndex<0 || initIndex>=numberOfVacanc
165 {G4Exception("G4RDAugerData::NumberOfAuger
166 FatalException, "VacancyIndex
167 else {
168 trans_Table::const_iterator element = auge
169 if (element == augerTransitionTable.end())
170 {G4Exception("G4RDAugerData::NumberOfAug
171 FatalException, "Data not l
172 std::vector<G4RDAugerTransition> dataSet =
173 const std::vector<G4int>* temp = dataSet[
174 n = temp->size();
175 }
176 return n;
177 }
178
179 size_t G4RDAugerData::AugerShellId(G4int Z, G4
180 {
181 size_t n = 0;
182 if (vacancyIndex<0 || vacancyIndex>=numberOf
183 {G4Exception("G4RDAugerData::AugerShellId(
184 FatalException, "VacancyIndex
185 else {
186 trans_Table::const_iterator element = auge
187 if (element == augerTransitionTable.end())
188 {G4Exception("G4RDAugerData::AugerShellI
189 FatalException, "Data not l
190 std::vector<G4RDAugerTransition> dataSet =
191 n = dataSet[vacancyIndex].AugerOriginating
192 }
193 return n;
194 }
195
196 G4int G4RDAugerData::StartShellId(G4int Z, G4i
197 {
198 G4int n = 0;
199
200 if (vacancyIndex<0 || vacancyIndex>=numberOf
201 {G4Exception("G4RDAugerData::StartShellId(
202 FatalException, "VacancyIndex
203 else {
204 trans_Table::const_iterator element = auge
205 if (element == augerTransitionTable.end())
206 {G4Exception("G4RDAugerData::StartShellI
207 FatalException, "Data not l
208 std::vector<G4RDAugerTransition> dataSet =
209 n = dataSet[vacancyIndex].TransitionOrigi
210 }
211
212
213 return n;
214 }
215
216 G4double G4RDAugerData::StartShellEnergy(G4int
217 {
218 G4double energy = 0;
219
220 if (vacancyIndex<0 || vacancyIndex>=numberOf
221 {G4Exception("G4RDAugerData::StartShellEne
222 FatalException, "VacancyIndex
223 else {
224 trans_Table::const_iterator element = auge
225 if (element == augerTransitionTable.end())
226 {G4Exception("G4RDAugerData::StartShellE
227 FatalException, "Data not l
228 std::vector<G4RDAugerTransition> dataSet =
229 energy = dataSet[vacancyIndex].AugerTransi
230
231 }
232 return energy;
233 }
234
235
236 G4double G4RDAugerData::StartShellProb(G4int Z
237 {
238 G4double prob = 0;
239
240 if (vacancyIndex<0 || vacancyIndex>=numberOf
241 {G4Exception("G4RDAugerData::StartShellPro
242 FatalException, "VacancyIndex
243 else {
244 trans_Table::const_iterator element = auge
245 if (element == augerTransitionTable.end())
246 {G4Exception("G4RDAugerData::StartShellP
247 FatalException, "Data not l
248 std::vector<G4RDAugerTransition> dataSet =
249 prob = dataSet[vacancyIndex].AugerTransiti
250
251
252
253 }
254 return prob;
255 }
256
257 std::vector<G4RDAugerTransition> G4RDAugerData
258 {
259 // Build the complete string identifying the
260
261 std::ostringstream ost;
262 if(Z != 0){
263 ost << "au-tr-pr-"<< Z << ".dat";
264 }
265 else{
266 ost << "au-tr-pr-"<<".dat";
267 }
268 G4String name(ost.str());
269
270 const char* path = G4FindDataDir("G4LEDATA
271 if (!path)
272 {
273 G4String excep = "G4LEDATA environment varia
274 G4Exception("G4RDAugerData::LoadData()", "In
275 FatalException, excep);
276 }
277
278 G4String pathString(path);
279 G4String dirFile = pathString + "/auger/"
280 std::ifstream file(dirFile);
281 std::filebuf* lsdp = file.rdbuf();
282
283 if (! (lsdp->is_open()) )
284 {
285 G4String excep = "Data file: " + dirFile + "
286 G4Exception("G4RDAugerData::LoadData()", "Da
287 FatalException, excep);
288 }
289
290
291 G4double a = 0;
292 G4int k = 1;
293 G4int s = 0;
294
295 G4int vacId = 0;
296 std::vector<G4int>* initIds = new std::vec
297 std::vector<G4int>* newIds = new std::vect
298 G4DataVector* transEnergies = new G4DataVe
299 G4DataVector* transProbabilities = new G4D
300 std::vector<G4RDAugerTransition> augerTran
301 std::map<G4int,std::vector<G4int>,std::les
302 new std::map<G4int,std::vector<G4int>,st
303 std::map<G4int,G4DataVector,std::less<G4in
304 new std::map<G4int,G4DataVector,std::les
305 std::map<G4int,G4DataVector,std::less<G4in
306 new std::map<G4int,G4DataVector,std::les
307
308
309 do {
310 file >> a;
311
312
313 G4int nColumns = 4;
314
315 if (a == -1)
316 {
317
318
319
320 if (s == 0)
321 {
322 // End of a shell data set
323
324
325
326 std::vector<G4int>::iterator vectorInd
327
328 vacId = *vectorIndex;
329
330 //initIds->erase(vectorIndex);
331
332
333
334 std::vector<G4int> identifiers;
335 for (vectorIndex = initIds->begin()+1
336
337 identifiers.push_back(*vectorIndex);
338 }
339
340 vectorIndex = (initIds->end())-1;
341
342 G4int augerShellId = *(vectorIndex);
343
344
345 (*newIdMap)[augerShellId] = *newIds;
346 (*newEnergyMap)[augerShellId] = *trans
347 (*newProbabilityMap)[augerShellId] = *
348
349 augerTransitionVector.push_back(G4RDAu
350
351 // Now deleting all the variables I us
352
353 delete newIdMap;
354 delete newEnergyMap;
355 delete newProbabilityMap;
356
357 G4int n = initIds->size();
358 nInitShells.push_back(n);
359 numberOfVacancies[Z]++;
360 delete initIds;
361 delete newIds;
362 delete transEnergies;
363 delete transProbabilities;
364 initIds = new std::vector<G4int>;
365 newIds = new std::vector<G4int>;
366 transEnergies = new G4DataVector;
367 transProbabilities = new G4DataVector;
368 newIdMap = new std::map<G4int,std::vec
369 newEnergyMap = new std::map<G4int,G4Da
370 newProbabilityMap = new std::map<G4int
371
372
373
374 }
375 s++;
376 if (s == nColumns)
377 {
378 s = 0;
379 }
380 }
381 else if (a == -2)
382 {
383 // End of file; delete the empty vectors c
384 //when encountering the last -1 -1 row
385 delete initIds;
386 delete newIds;
387 delete transEnergies;
388 delete transProbabilities;
389 delete newIdMap ;
390 delete newEnergyMap;
391 delete newProbabilityMap;
392 }
393 else
394 {
395
396 if (k%nColumns == 3){
397 // 3rd column is the transition probabil
398 transProbabilities->push_back(a);
399
400 k++;}
401 else if(k%nColumns == 2){
402 // 2nd column is new auger vacancy
403
404 // 2nd column is new auger vacancy
405
406 G4int l = (G4int)a;
407 newIds->push_back(l);
408
409
410 k++;
411 }
412 else if (k%nColumns == 1)
413 {
414 // 1st column is shell id
415
416 if(initIds->size() == 0) {
417
418 // if this is the first data of the shell,
419 // to the shell Id; so we skip the next co
420
421 initIds->push_back((G4int)a);
422 // first line of initIds is the original s
423 file >> a;
424 file >> a;
425 file >> a;
426 k = k+3;
427 }
428 else {
429
430 // std::vector<G4int>::iterator vec
431 if((G4int)a != initIds->back()){
432
433
434 if((initIds->size()) == 1) {
435 initIds->push_back((G4int)a);
436 }
437 else {
438
439
440 G4int augerShellId = 0;
441 augerShellId = initIds->back();
442
443 (*newIdMap)[augerShellId] = *newIds;
444 (*newEnergyMap)[augerShellId] = *trans
445 (*newProbabilityMap)[augerShellId] = *
446 delete newIds;
447 delete transEnergies;
448 delete transProbabilities;
449 newIds = new std::vector<G4int>;
450 transEnergies = new G4DataVector;
451 transProbabilities = new G4DataVector;
452 initIds->push_back((G4int)a);
453 }
454 }
455 }
456
457 k++;
458
459 }
460 else if (k%nColumns == 0)
461
462 {//fourth column is transition energies
463 G4double e = a * MeV;
464
465 transEnergies->push_back(e);
466 k=1;
467
468 }
469 }
470 }
471
472
473 while (a != -2); // end of file
474 file.close();
475 return augerTransitionVector;
476
477 }
478
479 void G4RDAugerData::BuildAugerTransitionTable(
480 {
481
482 // trans_Table::iterator pos = augerTransit
483
484 const G4MaterialTable* materialTable = G4Mat
485
486 G4int nMaterials = G4Material::GetNumberOfMa
487
488 G4DataVector activeZ;
489 activeZ.clear();
490
491 for (G4int m=0; m<nMaterials; m++) {
492
493 const G4Material* material= (*materialTabl
494 const G4ElementVector* elementVector = mat
495 const size_t nElements = material->GetNumb
496
497 for (size_t iEl=0; iEl<nElements; iEl++) {
498 G4Element* element = (*elementVector)[iE
499 G4double Z = element->GetZ();
500 if (!(activeZ.contains(Z))) {
501 activeZ.push_back(Z);
502 }
503 }
504 }
505
506
507 for (G4int element = 6; element < 101; eleme
508 {
509 if(nMaterials == 0 || activeZ.contains(e
510 augerTransitionTable.insert(trans_Tabl
511
512 G4cout << "G4RDAugerData for Element n
513 // PrintData(element);
514 }
515 }
516
517 G4cout << "AugerTransitionTable complete"<<
518 }
519
520 void G4RDAugerData::PrintData(G4int Z)
521 {
522
523 for (G4int i = 0; i < numberOfVacancies[Z];
524 {
525 G4cout << "---- TransitionData for the v
526 <<i
527 <<" of the atomic number elemnt "
528 << Z
529 <<"----- "
530 <<G4endl;
531
532 for (size_t k = 0; k<=NumberOfTransition
533 {
534 G4int id = StartShellId(Z,i,k);
535
536 for (size_t a = 0; a <= NumberOfAuger(Z,i,
537
538 G4double e = StartShellEnergy(Z,i,id,a)
539 G4double p = StartShellProb(Z,i,id,a);
540 G4int augerId = AugerShellId(Z, i, id, a
541 G4cout << k <<") Shell id: " << id <<G4e
542 G4cout << " Auger Originatig Shell Id
543 G4cout << " - Transition energy = " << e
544 G4cout << " - Transition probability =
545 }
546 }
547 G4cout << "-----------------------------
548 << G4endl;
549 }
550 }
551 G4RDAugerTransition* G4RDAugerData::GetAugerTr
552 {
553 std::vector<G4RDAugerTransition>* dataSe
554 std::vector<G4RDAugerTransition>::iterat
555
556 G4RDAugerTransition* augerTransition = &
557 return augerTransition;
558 }
559
560 std::vector<G4RDAugerTransition>* G4RDAugerDat
561 {
562 std::vector<G4RDAugerTransition>* dataSet
563 return dataSet;
564 }
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586