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