56 for (pos = 0 ; pos < 100; pos++)
58 numberOfVacancies.push_back(n);
115 return numberOfVacancies[
Z];
122 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
127 trans_Table::const_iterator element = augerTransitionTable.find(Z);
128 if (element == augerTransitionTable.end()) {
132 std::vector<G4AugerTransition> dataSet = (*element).second;
133 n = (
G4int) dataSet[vacancyIndex].FinalShellId();
145 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
151 trans_Table::const_iterator element = augerTransitionTable.find(Z);
152 if (element == augerTransitionTable.end())
157 std::vector<G4AugerTransition> dataSet = (*element).second;
158 n = (
G4int)dataSet[vacancyIndex].TransitionOriginatingShellIds()->size();
168 if (initIndex<0 || initIndex>=numberOfVacancies[Z])
174 trans_Table::const_iterator element = augerTransitionTable.find(Z);
175 if (element == augerTransitionTable.end()) {
179 std::vector<G4AugerTransition> dataSet = (*element).second;
180 const std::vector<G4int>* temp = dataSet[initIndex].AugerOriginatingShellIds(vacancyId);
189 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
195 trans_Table::const_iterator element = augerTransitionTable.find(Z);
196 if (element == augerTransitionTable.end()) {
200 std::vector<G4AugerTransition> dataSet = (*element).second;
201 n = dataSet[vacancyIndex].AugerOriginatingShellId(augerIndex,transId);
210 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
216 trans_Table::const_iterator element = augerTransitionTable.find(Z);
217 if (element == augerTransitionTable.end()) {
221 std::vector<G4AugerTransition> dataSet = (*element).second;
222 n = dataSet[vacancyIndex].TransitionOriginatingShellId(transitionShellIndex);
233 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
239 trans_Table::const_iterator element = augerTransitionTable.find(Z);
240 if (element == augerTransitionTable.end()) {
244 std::vector<G4AugerTransition> dataSet = (*element).second;
245 energy = dataSet[vacancyIndex].AugerTransitionEnergy(augerIndex,transitionId);
256 if (vacancyIndex<0 || vacancyIndex>=numberOfVacancies[Z])
262 trans_Table::const_iterator element = augerTransitionTable.find(Z);
263 if (element == augerTransitionTable.end()) {
267 std::vector<G4AugerTransition> dataSet = (*element).second;
268 prob = dataSet[vacancyIndex].AugerTransitionProbability(augerIndex, transitionId);
280 std::ostringstream ost;
282 ost <<
"au-tr-pr-"<< Z <<
".dat";
285 ost <<
"au-tr-pr-"<<
".dat";
289 char* path = getenv(
"G4LEDATA");
292 G4String excep =
"G4AugerData::LoadData";
294 std::vector<G4AugerTransition>
a;
300 std::ifstream
file(dirFile);
301 std::filebuf* lsdp = file.rdbuf();
303 if (! (lsdp->is_open()) )
305 G4String excep =
"G4AugerData::LoadData";
316 std::vector<G4int>* initIds =
new std::vector<G4int>;
317 std::vector<G4int>* newIds =
new std::vector<G4int>;
320 std::vector<G4AugerTransition> augerTransitionVector;
321 std::map<G4int,std::vector<G4int>,std::less<G4int> >* newIdMap =
322 new std::map<G4int,std::vector<G4int>,std::less<G4int> >;
323 std::map<G4int,G4DataVector,std::less<G4int> >* newEnergyMap =
324 new std::map<G4int,G4DataVector,std::less<G4int> >;
325 std::map<G4int,G4DataVector,std::less<G4int> >* newProbabilityMap =
326 new std::map<G4int,G4DataVector,std::less<G4int> >;
346 std::vector<G4int>::iterator vectorIndex = initIds->begin();
348 vacId = *vectorIndex;
354 std::vector<G4int> identifiers;
355 for (vectorIndex = initIds->begin()+1 ; vectorIndex != initIds->end(); ++vectorIndex){
357 identifiers.push_back(*vectorIndex);
360 vectorIndex = (initIds->end())-1;
362 G4int augerShellId = *(vectorIndex);
365 (*newIdMap)[augerShellId] = *newIds;
366 (*newEnergyMap)[augerShellId] = *transEnergies;
367 (*newProbabilityMap)[augerShellId] = *transProbabilities;
369 augerTransitionVector.push_back(
G4AugerTransition(vacId, identifiers, newIdMap, newEnergyMap, newProbabilityMap));
375 delete newProbabilityMap;
377 G4int n = initIds->size();
378 nInitShells.push_back(n);
379 numberOfVacancies[
Z]++;
382 delete transEnergies;
383 delete transProbabilities;
384 initIds =
new std::vector<G4int>;
385 newIds =
new std::vector<G4int>;
388 newIdMap =
new std::map<G4int,std::vector<G4int>,std::less<G4int> >;
389 newEnergyMap =
new std::map<G4int,G4DataVector,std::less<G4int> >;
390 newProbabilityMap =
new std::map<G4int,G4DataVector,std::less<G4int> >;
396 if (sLocal == nColumns)
418 if (k%nColumns == 3){
420 transProbabilities->push_back(a);
423 else if(k%nColumns == 2){
429 newIds->push_back(l);
434 else if (k%nColumns == 1)
438 if(initIds->size() == 0) {
443 initIds->push_back((
G4int)a);
453 if((
G4int)a != initIds->back()){
456 if((initIds->size()) == 1) {
457 initIds->push_back((
G4int)a);
462 G4int augerShellId = 0;
463 augerShellId = initIds->back();
465 (*newIdMap)[augerShellId] = *newIds;
466 (*newEnergyMap)[augerShellId] = *transEnergies;
467 (*newProbabilityMap)[augerShellId] = *transProbabilities;
469 delete transEnergies;
470 delete transProbabilities;
471 newIds =
new std::vector<G4int>;
474 initIds->push_back((
G4int)a);
482 else if (k%nColumns == 0)
487 transEnergies->push_back(e);
499 delete transEnergies;
500 delete transProbabilities;
503 delete newProbabilityMap;
504 return augerTransitionVector;
520 for (
G4int mLocal=0; mLocal<nMaterials; mLocal++) {
526 for (
size_t iEl=0; iEl<nElements; iEl++) {
527 G4Element* element = (*elementVector)[iEl];
530 activeZ.push_back(Z);
536 for (
G4int element = 6; element < 100; element++)
539 augerTransitionTable.insert(trans_Table::value_type(element,
LoadData(element)));
549 for (
G4int i = 0; i < numberOfVacancies[
Z]; i++)
551 G4cout <<
"---- TransitionData for the vacancy nb "
553 <<
" of the atomic number elemnt "
568 G4cout <<
" Auger Originatig Shell Id :"<< augerId <<
G4endl;
569 G4cout <<
" - Transition energy = " << e <<
" MeV "<<
G4endl;
573 G4cout <<
"-------------------------------------------------"
579 std::vector<G4AugerTransition>* dataSet = &augerTransitionTable[
Z];
580 std::vector<G4AugerTransition>::iterator vectorIndex = dataSet->begin() + vacancyShellIndex;
583 return augerTransition;
588 std::vector<G4AugerTransition>* dataSet = &augerTransitionTable[
Z];
std::vector< G4AugerTransition > LoadData(G4int Z)
G4double StartShellProb(G4int Z, G4int vacancyIndex, G4int transitionId, G4int augerIndex) const
G4double StartShellEnergy(G4int Z, G4int vacancyIndex, G4int transitionId, G4int augerIndex) const
std::vector< G4Element * > G4ElementVector
static G4MaterialTable * GetMaterialTable()
std::vector< G4Material * > G4MaterialTable
size_t AugerShellId(G4int Z, G4int vacancyIndex, G4int transId, G4int augerIndex) const
const G4ElementVector * GetElementVector() const
size_t NumberOfAuger(G4int Z, G4int initIndex, G4int vacancyId) const
std::vector< G4AugerTransition > * GetAugerTransitions(G4int Z)
void BuildAugerTransitionTable()
G4int StartShellId(G4int Z, G4int initialVacancyIndex, G4int transitionShellIndex) const
G4GLOB_DLL std::ostream G4cout
static size_t GetNumberOfMaterials()
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
size_t NumberOfTransitions(G4int Z, G4int vacancyIndex) const
G4int VacancyId(G4int Z, G4int vacancyIndex) const
size_t GetNumberOfElements() const
G4AugerTransition * GetAugerTransition(G4int Z, G4int vacancyShellIndex)
G4bool contains(const G4double &) const
size_t NumberOfVacancies(G4int Z) const