ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4RDAugerData.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4RDAugerData.cc
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 //
28 //
29 // Author: Alfonso Mmantero (Alfonso.Mantero@ge.infn.it)
30 //
31 // History:
32 // -----------
33 // Based on G4RDFluoData by Elena Guardincerri
34 //
35 // Modified: 30.07.02 VI Add select active Z + clean up against pedantic compiler
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 
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 
62 
63 
64 }
65 
67 {
68  /*
69  std::map<G4int,std::vector<G4RDAugerTransition>,std::less<G4int> >::iterator pos;
70 
71  for (pos = augerTransitionTable.begin(); pos != augerTransitionTable.end(); pos++)
72  {
73  std::vector<G4RDAugerTransition> dataSet = (*pos).second;
74  delete dataSet;
75  }
76  for (pos = energyMap.begin(); pos != energyMap.end(); pos++)
77  {
78  std::map<G4Int,G4DataVector*,std::less<G4int>>* dataMap = (*pos).second;
79  for (pos2 = newIdProbabilityMap.begin(); pos2 != idMap.end(); pos2++)
80  {
81  G4DataVector* dataSet = (*pos2).second;
82  delete dataSet;
83  }
84  }
85  for (pos = probabilityMap.begin(); pos != probabilityMap.end(); pos++)
86  {
87  std::map<G4Int,G4DataVector*,std::less<G4int>>* dataMap = (*pos).second;
88  for (pos2 = newIdProbabilityMap.begin(); pos2 != idMap.end(); pos2++)
89  {
90  G4DataVector* dataSet = (*pos2).second;
91  delete dataSet;
92  }
93  }
94  for (pos2 = newIdMap.begin(); pos2 != idMap.end(); pos2++)
95  {
96  G4DataVector* dataSet = (*pos2).second;
97  delete dataSet;
98  }
99  for (pos2 = newIdEnergyMap.begin(); pos2 != idMap.end(); pos2++)
100  {
101  G4DataVector* dataSet = (*pos2).second;
102  delete dataSet;
103  }
104  for (pos2 = newIdProbabilityMap.begin(); pos2 != idMap.end(); pos2++)
105  {
106  G4DataVector* dataSet = (*pos2).second;
107  delete dataSet;
108  }
109  */
110 
111 }
112 
114 {
115  return numberOfVacancies[Z];
116 }
117 
119 {
120 
121  G4int n = 0;
122  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
123  {G4Exception("G4RDAugerData::VacancyId()", "OutOfRange",
124  FatalException, "VacancyIndex outside boundaries!");}
125  else {
126  trans_Table::const_iterator element = augerTransitionTable.find(Z);
127  if (element == augerTransitionTable.end())
128  {G4Exception("G4RDAugerData::VacancyId()", "NoDataFound",
129  FatalException, "Data not loaded!");}
130  std::vector<G4RDAugerTransition> dataSet = (*element).second;
131  n = (G4int) dataSet[vacancyIndex].FinalShellId();
132  }
133 
134  return n;
135 }
136 
137 
138 
139 // Attenzione: questa funzione vuole l'indice della vacanza, non l'Id
140 
141 
142 size_t G4RDAugerData::NumberOfTransitions(G4int Z, G4int vacancyIndex) const
143 {
144  G4int n = 0;
145  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
146  {G4Exception("G4RDAugerData::NumberOfTransitions()", "OutOfRange",
147  FatalException, "VacancyIndex outside boundaries!");}
148  else {
149  trans_Table::const_iterator element = augerTransitionTable.find(Z);
150  if (element == augerTransitionTable.end())
151  {G4Exception("G4RDAugerData::NumberOfTransitions()", "NoDataFound",
152  FatalException, "Data not loaded!");}
153  std::vector<G4RDAugerTransition> dataSet = (*element).second;
154  n = (G4int)dataSet[vacancyIndex].TransitionOriginatingShellIds()->size();
155  }
156  return n;
157 }
158 
159 
160 
161 size_t G4RDAugerData::NumberOfAuger(G4int Z, G4int initIndex, G4int vacancyId) const
162 {
163  size_t n = 0;
164  if (initIndex<0 || initIndex>=numberOfVacancies[Z])
165  {G4Exception("G4RDAugerData::NumberOfAuger()", "OutOfRange",
166  FatalException, "VacancyIndex outside boundaries!");}
167  else {
168  trans_Table::const_iterator element = augerTransitionTable.find(Z);
169  if (element == augerTransitionTable.end())
170  {G4Exception("G4RDAugerData::NumberOfAuger()", "NoDataFound",
171  FatalException, "Data not loaded!");}
172  std::vector<G4RDAugerTransition> dataSet = (*element).second;
173  const std::vector<G4int>* temp = dataSet[initIndex].AugerOriginatingShellIds(vacancyId);
174  n = temp->size();
175  }
176  return n;
177 }
178 
179 size_t G4RDAugerData::AugerShellId(G4int Z, G4int vacancyIndex, G4int transId, G4int augerIndex) const
180 {
181  size_t n = 0;
182  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
183  {G4Exception("G4RDAugerData::AugerShellId()", "OutOfRange",
184  FatalException, "VacancyIndex outside boundaries!");}
185  else {
186  trans_Table::const_iterator element = augerTransitionTable.find(Z);
187  if (element == augerTransitionTable.end())
188  {G4Exception("G4RDAugerData::AugerShellId()", "NoDataFound",
189  FatalException, "Data not loaded!");}
190  std::vector<G4RDAugerTransition> dataSet = (*element).second;
191  n = dataSet[vacancyIndex].AugerOriginatingShellId(augerIndex,transId);
192  }
193  return n;
194 }
195 
196 G4int G4RDAugerData::StartShellId(G4int Z, G4int vacancyIndex, G4int transitionShellIndex) const
197 {
198  G4int n = 0;
199 
200  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
201  {G4Exception("G4RDAugerData::StartShellId()", "OutOfRange",
202  FatalException, "VacancyIndex outside boundaries!");}
203  else {
204  trans_Table::const_iterator element = augerTransitionTable.find(Z);
205  if (element == augerTransitionTable.end())
206  {G4Exception("G4RDAugerData::StartShellId()", "NoDataFound",
207  FatalException, "Data not loaded!");}
208  std::vector<G4RDAugerTransition> dataSet = (*element).second;
209  n = dataSet[vacancyIndex].TransitionOriginatingShellId(transitionShellIndex);
210  }
211 
212 
213  return n;
214 }
215 
216 G4double G4RDAugerData::StartShellEnergy(G4int Z, G4int vacancyIndex, G4int transitionId, G4int augerIndex) const
217 {
218  G4double energy = 0;
219 
220  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
221  {G4Exception("G4RDAugerData::StartShellEnergy()", "OutOfRange",
222  FatalException, "VacancyIndex outside boundaries!");}
223  else {
224  trans_Table::const_iterator element = augerTransitionTable.find(Z);
225  if (element == augerTransitionTable.end())
226  {G4Exception("G4RDAugerData::StartShellEnergy()", "NoDataFound",
227  FatalException, "Data not loaded!");}
228  std::vector<G4RDAugerTransition> dataSet = (*element).second;
229  energy = dataSet[vacancyIndex].AugerTransitionEnergy(augerIndex,transitionId);
230 
231  }
232  return energy;
233 }
234 
235 
236 G4double G4RDAugerData::StartShellProb(G4int Z, G4int vacancyIndex,G4int transitionId,G4int augerIndex) const
237 {
238  G4double prob = 0;
239 
240  if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
241  {G4Exception("G4RDAugerData::StartShellProb()", "OutOfRange",
242  FatalException, "VacancyIndex outside boundaries!");}
243  else {
244  trans_Table::const_iterator element = augerTransitionTable.find(Z);
245  if (element == augerTransitionTable.end())
246  {G4Exception("G4RDAugerData::StartShellProb()", "NoDataFound",
247  FatalException, "Data not loaded!");}
248  std::vector<G4RDAugerTransition> dataSet = (*element).second;
249  prob = dataSet[vacancyIndex].AugerTransitionProbability(augerIndex, transitionId);
250 
251 
252 
253  }
254  return prob;
255 }
256 
257 std::vector<G4RDAugerTransition> G4RDAugerData::LoadData(G4int Z)
258 {
259  // Build the complete string identifying the file with the data set
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  char* path = std::getenv("G4LEDATA");
271  if (!path)
272  {
273  G4String excep = "G4LEDATA environment variable not set";
274  G4Exception("G4RDAugerData::LoadData()", "InvalidSetup",
275  FatalException, excep);
276  }
277 
278  G4String pathString(path);
279  G4String dirFile = pathString + "/auger/" + name;
280  std::ifstream file(dirFile);
281  std::filebuf* lsdp = file.rdbuf();
282 
283  if (! (lsdp->is_open()) )
284  {
285  G4String excep = "Data file: " + dirFile + " not found!";
286  G4Exception("G4RDAugerData::LoadData()", "DataNotFound",
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::vector<G4int>;
297  std::vector<G4int>* newIds = new std::vector<G4int>;
298  G4DataVector* transEnergies = new G4DataVector;
299  G4DataVector* transProbabilities = new G4DataVector;
300  std::vector<G4RDAugerTransition> augerTransitionVector;
301  std::map<G4int,std::vector<G4int>,std::less<G4int> >* newIdMap =
302  new std::map<G4int,std::vector<G4int>,std::less<G4int> >;
303  std::map<G4int,G4DataVector,std::less<G4int> >* newEnergyMap =
304  new std::map<G4int,G4DataVector,std::less<G4int> >;
305  std::map<G4int,G4DataVector,std::less<G4int> >* newProbabilityMap =
306  new std::map<G4int,G4DataVector,std::less<G4int> >;
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 vectorIndex = initIds->begin();
327 
328  vacId = *vectorIndex;
329 
330  //initIds->erase(vectorIndex);
331 
332 
333 
334  std::vector<G4int> identifiers;
335  for (vectorIndex = initIds->begin()+1 ; vectorIndex != initIds->end(); ++vectorIndex){
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] = *transEnergies;
347  (*newProbabilityMap)[augerShellId] = *transProbabilities;
348 
349  augerTransitionVector.push_back(G4RDAugerTransition(vacId, identifiers, newIdMap, newEnergyMap, newProbabilityMap));
350 
351  // Now deleting all the variables I used, and creating new ones for the next shell
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::vector<G4int>,std::less<G4int> >;
369  newEnergyMap = new std::map<G4int,G4DataVector,std::less<G4int> >;
370  newProbabilityMap = new std::map<G4int,G4DataVector,std::less<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 created
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 probabilities
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, all the colums are equal
419  // to the shell Id; so we skip the next colums ang go to the next row
420 
421  initIds->push_back((G4int)a);
422  // first line of initIds is the original shell of the vacancy
423  file >> a;
424  file >> a;
425  file >> a;
426  k = k+3;
427  }
428  else {
429 
430  // std::vector<G4int>::iterator vectorIndex = (initIds->end())-1;
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] = *transEnergies;
445  (*newProbabilityMap)[augerShellId] = *transProbabilities;
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 
480 {
481 
482  // trans_Table::iterator pos = augerTransitionTable.begin();
483 
484  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
485 
487 
488  G4DataVector activeZ;
489  activeZ.clear();
490 
491  for (G4int m=0; m<nMaterials; m++) {
492 
493  const G4Material* material= (*materialTable)[m];
494  const G4ElementVector* elementVector = material->GetElementVector();
495  const size_t nElements = material->GetNumberOfElements();
496 
497  for (size_t iEl=0; iEl<nElements; iEl++) {
498  G4Element* element = (*elementVector)[iEl];
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; element++)
508  {
509  if(nMaterials == 0 || activeZ.contains(element)) {
510  augerTransitionTable.insert(trans_Table::value_type(element,LoadData(element)));
511 
512  G4cout << "G4RDAugerData for Element no. " << element << " are loaded" << G4endl;
513  // PrintData(element);
514  }
515  }
516 
517  G4cout << "AugerTransitionTable complete"<< G4endl;
518 }
519 
521 {
522 
523  for (G4int i = 0; i < numberOfVacancies[Z]; i++)
524  {
525  G4cout << "---- TransitionData for the vacancy nb "
526  <<i
527  <<" of the atomic number elemnt "
528  << Z
529  <<"----- "
530  <<G4endl;
531 
532  for (size_t k = 0; k<=NumberOfTransitions(Z,i); k++)
533  {
534  G4int id = StartShellId(Z,i,k);
535 
536  for (size_t a = 0; a <= NumberOfAuger(Z,i,id); a++) {
537 
538  G4double e = StartShellEnergy(Z,i,id,a) /MeV;
539  G4double p = StartShellProb(Z,i,id,a);
540  G4int augerId = AugerShellId(Z, i, id, a);
541  G4cout << k <<") Shell id: " << id <<G4endl;
542  G4cout << " Auger Originatig Shell Id :"<< augerId <<G4endl;
543  G4cout << " - Transition energy = " << e << " MeV "<<G4endl;
544  G4cout << " - Transition probability = " << p <<G4endl;
545  }
546  }
547  G4cout << "-------------------------------------------------"
548  << G4endl;
549  }
550 }
552  {
553  std::vector<G4RDAugerTransition>* dataSet = &augerTransitionTable[Z];
554  std::vector<G4RDAugerTransition>::iterator vectorIndex = dataSet->begin() + vacancyShellIndex;
555 
556  G4RDAugerTransition* augerTransition = &(*vectorIndex);
557  return augerTransition;
558  }
559 
560 std::vector<G4RDAugerTransition>* G4RDAugerData::GetAugerTransitions(G4int Z)
561  {
562  std::vector<G4RDAugerTransition>* dataSet = &augerTransitionTable[Z];
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