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 // 27 // 28 // Authors: Elena Guardincerri (Elena.Guardinc 28 // Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it) 29 // Alfonso Mantero (Alfonso.Mantero@g 29 // Alfonso Mantero (Alfonso.Mantero@ge.infn.it) 30 // 30 // 31 // History: 31 // History: 32 // ----------- 32 // ----------- 33 // 33 // 34 // 16 Sept 2001 First committed to cvs 34 // 16 Sept 2001 First committed to cvs 35 // 12 Sep 2003 Bug in auger production fixe 35 // 12 Sep 2003 Bug in auger production fixed 36 // 36 // 37 // ------------------------------------------- 37 // ------------------------------------------------------------------- 38 38 39 #include "G4AtomicDeexcitation.hh" 39 #include "G4AtomicDeexcitation.hh" 40 #include "Randomize.hh" 40 #include "Randomize.hh" 41 #include "G4PhysicalConstants.hh" 41 #include "G4PhysicalConstants.hh" 42 #include "G4SystemOfUnits.hh" 42 #include "G4SystemOfUnits.hh" 43 #include "G4Gamma.hh" 43 #include "G4Gamma.hh" 44 #include "G4Electron.hh" 44 #include "G4Electron.hh" 45 #include "G4AtomicTransitionManager.hh" 45 #include "G4AtomicTransitionManager.hh" 46 #include "G4FluoTransition.hh" 46 #include "G4FluoTransition.hh" 47 47 48 G4AtomicDeexcitation::G4AtomicDeexcitation(): 48 G4AtomicDeexcitation::G4AtomicDeexcitation(): 49 minGammaEnergy(100.*eV), 49 minGammaEnergy(100.*eV), 50 minElectronEnergy(100.*eV), 50 minElectronEnergy(100.*eV), 51 fAuger(false) 51 fAuger(false) 52 { 52 { 53 53 54 G4cout << " ******************************** 54 G4cout << " ********************************************************** " << G4endl; 55 G4cout << " * W A R N I N G 55 G4cout << " * W A R N I N G ! ! ! * " << G4endl; 56 G4cout << " ******************************** 56 G4cout << " ********************************************************** " << G4endl; 57 G4cout << " * 57 G4cout << " * * " << G4endl; 58 G4cout << " * Class G4AtomicDeexcitation is 58 G4cout << " * Class G4AtomicDeexcitation is obsolete. It has been * " << G4endl; 59 G4cout << " * discontinued and is going to b 59 G4cout << " * discontinued and is going to be removed by next Geant4 * " << G4endl; 60 G4cout << " * release please migrate to 60 G4cout << " * release please migrate to G4UAtomDeexcitation. * " << G4endl; 61 G4cout << " * 61 G4cout << " * * " << G4endl; 62 G4cout << " ******************************** 62 G4cout << " ********************************************************** " << G4endl; 63 63 64 augerVacancyId=0; 64 augerVacancyId=0; 65 newShellId=0; 65 newShellId=0; 66 } 66 } 67 67 68 G4AtomicDeexcitation::~G4AtomicDeexcitation() 68 G4AtomicDeexcitation::~G4AtomicDeexcitation() 69 {} 69 {} 70 70 71 std::vector<G4DynamicParticle*>* G4AtomicDeexc 71 std::vector<G4DynamicParticle*>* G4AtomicDeexcitation::GenerateParticles(G4int Z,G4int givenShellId) 72 { 72 { 73 73 74 std::vector<G4DynamicParticle*>* vectorOfPar 74 std::vector<G4DynamicParticle*>* vectorOfParticles; 75 vectorOfParticles = new std::vector<G4Dynami 75 vectorOfParticles = new std::vector<G4DynamicParticle*>; 76 76 77 G4DynamicParticle* aParticle = nullptr; << 77 G4DynamicParticle* aParticle; 78 G4int provShellId = 0; 78 G4int provShellId = 0; 79 G4int counter = 0; 79 G4int counter = 0; 80 80 81 // The aim of this loop is to generate more 81 // The aim of this loop is to generate more than one fluorecence photon 82 // from the same ionizing event 82 // from the same ionizing event 83 do 83 do 84 { 84 { 85 if (counter == 0) 85 if (counter == 0) 86 // First call to GenerateParticles(...): 86 // First call to GenerateParticles(...): 87 // givenShellId is given by the process 87 // givenShellId is given by the process 88 { 88 { 89 provShellId = SelectTypeOfTransition(Z, gi 89 provShellId = SelectTypeOfTransition(Z, givenShellId); 90 90 91 if ( provShellId >0) 91 if ( provShellId >0) 92 { 92 { 93 aParticle = GenerateFluorescence(Z,giv 93 aParticle = GenerateFluorescence(Z,givenShellId,provShellId); 94 } 94 } 95 else if ( provShellId == -1) 95 else if ( provShellId == -1) 96 { 96 { 97 aParticle = GenerateAuger(Z, givenShel 97 aParticle = GenerateAuger(Z, givenShellId); 98 } 98 } 99 else 99 else 100 { 100 { 101 G4Exception("G4AtomicDeexcitation::Con 101 G4Exception("G4AtomicDeexcitation::Constructor", "de0002", JustWarning, "Transition selection invalid, energy local deposited"); 102 } 102 } 103 } 103 } 104 else 104 else 105 // Following calls to GenerateParticles(...) 105 // Following calls to GenerateParticles(...): 106 // newShellId is given by GenerateFluorescen 106 // newShellId is given by GenerateFluorescence(...) 107 { 107 { 108 provShellId = SelectTypeOfTransition(Z,new 108 provShellId = SelectTypeOfTransition(Z,newShellId); 109 if (provShellId >0) 109 if (provShellId >0) 110 { 110 { 111 aParticle = GenerateFluorescence(Z,new 111 aParticle = GenerateFluorescence(Z,newShellId,provShellId); 112 } 112 } 113 else if ( provShellId == -1) 113 else if ( provShellId == -1) 114 { 114 { 115 aParticle = GenerateAuger(Z, newShellI 115 aParticle = GenerateAuger(Z, newShellId); 116 } 116 } 117 else 117 else 118 { 118 { 119 G4Exception("G4AtomicDeexcitation::con 119 G4Exception("G4AtomicDeexcitation::constructor", "de0002", JustWarning, "Transition selection invalid, energy local deposited" ); 120 } 120 } 121 } 121 } 122 counter++; 122 counter++; 123 if (aParticle != nullptr) {vectorOfParti << 123 if (aParticle != 0) {vectorOfParticles->push_back(aParticle);} 124 else {provShellId = -2;} 124 else {provShellId = -2;} 125 } 125 } 126 126 127 // Look this in a particular way: only one a 127 // Look this in a particular way: only one auger emitted! // ???? 128 while (provShellId > -2); 128 while (provShellId > -2); 129 129 130 // debug 130 // debug 131 // if (vectorOfParticles->size() > 0) { 131 // if (vectorOfParticles->size() > 0) { 132 // G4cout << " DEEXCITATION!" << G4endl; 132 // G4cout << " DEEXCITATION!" << G4endl; 133 // } 133 // } 134 134 135 return vectorOfParticles; 135 return vectorOfParticles; 136 } 136 } 137 137 138 G4int G4AtomicDeexcitation::SelectTypeOfTransi 138 G4int G4AtomicDeexcitation::SelectTypeOfTransition(G4int Z, G4int shellId) 139 { 139 { 140 if (shellId <=0 ) 140 if (shellId <=0 ) 141 {G4Exception("G4AtomicDeexcitation::Select 141 {G4Exception("G4AtomicDeexcitation::SelectTypeOfTransition()","de0002", JustWarning ,"zero or negative shellId");} 142 142 143 //G4bool fluoTransitionFoundFlag = false; 143 //G4bool fluoTransitionFoundFlag = false; 144 144 145 const G4AtomicTransitionManager* transition 145 const G4AtomicTransitionManager* transitionManager = 146 G4AtomicTransitionManager::Instance(); 146 G4AtomicTransitionManager::Instance(); 147 G4int provShellId = -1; 147 G4int provShellId = -1; 148 G4int shellNum = 0; 148 G4int shellNum = 0; 149 G4int maxNumOfShells = transitionManager->Nu 149 G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z); 150 150 151 const G4FluoTransition* refShell = transitio 151 const G4FluoTransition* refShell = transitionManager->ReachableShell(Z,maxNumOfShells-1); 152 152 153 // This loop gives shellNum the value of the 153 // This loop gives shellNum the value of the index of shellId 154 // in the vector storing the list of the she 154 // in the vector storing the list of the shells reachable through 155 // a radiative transition 155 // a radiative transition 156 if ( shellId <= refShell->FinalShellId()) 156 if ( shellId <= refShell->FinalShellId()) 157 { 157 { 158 while (shellId != transitionManager->Rea 158 while (shellId != transitionManager->ReachableShell(Z,shellNum)->FinalShellId()) 159 { 159 { 160 if(shellNum ==maxNumOfShells-1) 160 if(shellNum ==maxNumOfShells-1) 161 { 161 { 162 break; 162 break; 163 } 163 } 164 shellNum++; 164 shellNum++; 165 } 165 } 166 G4int transProb = 0; //AM change 29/6/07 166 G4int transProb = 0; //AM change 29/6/07 was 1 167 167 168 G4double partialProb = G4UniformRand(); 168 G4double partialProb = G4UniformRand(); 169 G4double partSum = 0; 169 G4double partSum = 0; 170 const G4FluoTransition* aShell = transit 170 const G4FluoTransition* aShell = transitionManager->ReachableShell(Z,shellNum); 171 G4int trSize = (G4int)(aShell->Transitio << 171 G4int trSize = (aShell->TransitionProbabilities()).size(); 172 172 173 // Loop over the shells wich can provide 173 // Loop over the shells wich can provide an electron for a 174 // radiative transition towards shellId: 174 // radiative transition towards shellId: 175 // in every loop the partial sum of the 175 // in every loop the partial sum of the first transProb shells 176 // is calculated and compared with a ran 176 // is calculated and compared with a random number [0,1]. 177 // If the partial sum is greater, the sh 177 // If the partial sum is greater, the shell whose index is transProb 178 // is chosen as the starting shell for a 178 // is chosen as the starting shell for a radiative transition 179 // and its identity is returned 179 // and its identity is returned 180 // Else, terminateded the loop, -1 is re 180 // Else, terminateded the loop, -1 is returned 181 while(transProb < trSize){ 181 while(transProb < trSize){ 182 182 183 partSum += aShell->TransitionProbability(tr 183 partSum += aShell->TransitionProbability(transProb); 184 184 185 if(partialProb <= partSum) 185 if(partialProb <= partSum) 186 { 186 { 187 provShellId = aShell->OriginatingShellI 187 provShellId = aShell->OriginatingShellId(transProb); 188 //fluoTransitionFoundFlag = true; 188 //fluoTransitionFoundFlag = true; 189 189 190 break; 190 break; 191 } 191 } 192 transProb++; 192 transProb++; 193 } 193 } 194 194 195 // here provShellId is the right one or 195 // here provShellId is the right one or is -1. 196 // if -1, the control is passed to the A 196 // if -1, the control is passed to the Auger generation part of the package 197 } 197 } >> 198 >> 199 >> 200 198 else 201 else 199 provShellId = -1; << 202 { >> 203 >> 204 provShellId = -1; 200 205 >> 206 } 201 return provShellId; 207 return provShellId; 202 } 208 } 203 209 204 G4DynamicParticle* G4AtomicDeexcitation::Gener 210 G4DynamicParticle* G4AtomicDeexcitation::GenerateFluorescence(G4int Z, 205 G4int shellId, 211 G4int shellId, 206 G4int provShellId ) 212 G4int provShellId ) 207 { 213 { >> 214 >> 215 208 const G4AtomicTransitionManager* transition 216 const G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance(); 209 // G4int provenienceShell = provShellId; 217 // G4int provenienceShell = provShellId; 210 218 211 //isotropic angular distribution for the out 219 //isotropic angular distribution for the outcoming photon 212 G4double newcosTh = 1.-2.*G4UniformRand(); 220 G4double newcosTh = 1.-2.*G4UniformRand(); 213 G4double newsinTh = std::sqrt(1.-newcosTh*n 221 G4double newsinTh = std::sqrt(1.-newcosTh*newcosTh); 214 G4double newPhi = twopi*G4UniformRand(); 222 G4double newPhi = twopi*G4UniformRand(); 215 223 216 G4double xDir = newsinTh*std::sin(newPhi); 224 G4double xDir = newsinTh*std::sin(newPhi); 217 G4double yDir = newsinTh*std::cos(newPhi); 225 G4double yDir = newsinTh*std::cos(newPhi); 218 G4double zDir = newcosTh; 226 G4double zDir = newcosTh; 219 227 220 G4ThreeVector newGammaDirection(xDir,yDir,zD 228 G4ThreeVector newGammaDirection(xDir,yDir,zDir); 221 229 222 G4int shellNum = 0; 230 G4int shellNum = 0; 223 G4int maxNumOfShells = transitionManager->Nu 231 G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z); 224 232 225 // find the index of the shell named shellId 233 // find the index of the shell named shellId 226 while (shellId != transitionManager-> 234 while (shellId != transitionManager-> 227 ReachableShell(Z,shellNum)->FinalShellId()) 235 ReachableShell(Z,shellNum)->FinalShellId()) 228 { 236 { 229 if(shellNum == maxNumOfShells-1) 237 if(shellNum == maxNumOfShells-1) 230 { 238 { 231 break; 239 break; 232 } 240 } 233 shellNum++; 241 shellNum++; 234 } 242 } 235 // number of shell from wich an electron can 243 // number of shell from wich an electron can reach shellId 236 G4int transitionSize = (G4int)transitionMana << 244 size_t transitionSize = transitionManager-> 237 ReachableShell(Z,shellNum)->OriginatingShe 245 ReachableShell(Z,shellNum)->OriginatingShellIds().size(); 238 246 239 G4int index = 0; << 247 size_t index = 0; 240 248 241 // find the index of the shell named provShe 249 // find the index of the shell named provShellId in the vector 242 // storing the shells from which shellId can 250 // storing the shells from which shellId can be reached 243 while (provShellId != transitionManager-> 251 while (provShellId != transitionManager-> 244 ReachableShell(Z,shellNum)->OriginatingShel 252 ReachableShell(Z,shellNum)->OriginatingShellId(index)) 245 { 253 { 246 if(index == transitionSize-1) 254 if(index == transitionSize-1) 247 { 255 { 248 break; 256 break; 249 } 257 } 250 index++; 258 index++; 251 } 259 } 252 // energy of the gamma leaving provShellId f 260 // energy of the gamma leaving provShellId for shellId 253 G4double transitionEnergy = transitionManage 261 G4double transitionEnergy = transitionManager-> 254 ReachableShell(Z,shellNum)->TransitionEner 262 ReachableShell(Z,shellNum)->TransitionEnergy(index); 255 263 256 // This is the shell where the new vacancy i 264 // This is the shell where the new vacancy is: it is the same 257 // shell where the electron came from 265 // shell where the electron came from 258 newShellId = transitionManager-> 266 newShellId = transitionManager-> 259 ReachableShell(Z,shellNum)->OriginatingShe 267 ReachableShell(Z,shellNum)->OriginatingShellId(index); 260 268 >> 269 261 G4DynamicParticle* newPart = new G4DynamicPa 270 G4DynamicParticle* newPart = new G4DynamicParticle(G4Gamma::Gamma(), 262 newGammaDirection, 271 newGammaDirection, 263 transitionEnergy); 272 transitionEnergy); 264 return newPart; 273 return newPart; 265 } 274 } 266 275 267 G4DynamicParticle* G4AtomicDeexcitation::Gener 276 G4DynamicParticle* G4AtomicDeexcitation::GenerateAuger(G4int Z, G4int shellId) 268 { 277 { 269 if(!fAuger) return 0; 278 if(!fAuger) return 0; 270 279 >> 280 271 const G4AtomicTransitionManager* transition 281 const G4AtomicTransitionManager* transitionManager = 272 G4AtomicTransitionManager::Instance(); 282 G4AtomicTransitionManager::Instance(); 273 283 >> 284 >> 285 274 if (shellId <=0 ) 286 if (shellId <=0 ) 275 {G4Exception("G4AtomicDeexcitation::Genera 287 {G4Exception("G4AtomicDeexcitation::GenerateAuger()","de0002", JustWarning ,"zero or negative shellId");} 276 288 277 // G4int provShellId = -1; 289 // G4int provShellId = -1; 278 G4int maxNumOfShells = transitionManager->Nu 290 G4int maxNumOfShells = transitionManager->NumberOfReachableAugerShells(Z); 279 291 280 const G4AugerTransition* refAugerTransition 292 const G4AugerTransition* refAugerTransition = 281 transitionManager->ReachableAugerShell 293 transitionManager->ReachableAugerShell(Z,maxNumOfShells-1); 282 294 283 295 284 // This loop gives to shellNum the value of 296 // This loop gives to shellNum the value of the index of shellId 285 // in the vector storing the list of the vac 297 // in the vector storing the list of the vacancies in the variuos shells 286 // that can originate a NON-radiative transi 298 // that can originate a NON-radiative transition >> 299 >> 300 // ---- MGP ---- Next line commented out to remove compilation warning >> 301 // G4int p = refAugerTransition->FinalShellId(); >> 302 287 G4int shellNum = 0; 303 G4int shellNum = 0; 288 304 >> 305 289 if ( shellId <= refAugerTransition->FinalShe 306 if ( shellId <= refAugerTransition->FinalShellId() ) 290 //"FinalShellId" is final from the point o 307 //"FinalShellId" is final from the point of view of the elctron who makes the transition, 291 // being the Id of the shell in which ther 308 // being the Id of the shell in which there is a vacancy 292 { 309 { 293 G4int pippo = transitionManager->Reachab 310 G4int pippo = transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId(); 294 if (shellId != pippo ) { 311 if (shellId != pippo ) { 295 do { 312 do { 296 shellNum++; 313 shellNum++; 297 if(shellNum == maxNumOfShells) 314 if(shellNum == maxNumOfShells) 298 { 315 { 299 316 300 //G4Exception("G4AtomicDeexcitation: N 317 //G4Exception("G4AtomicDeexcitation: No Auger transition found"); 301 return 0; 318 return 0; 302 } 319 } 303 } 320 } 304 while (shellId != (transitionManager->Reacha 321 while (shellId != (transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId()) ) ; 305 } 322 } 306 323 >> 324 >> 325 // Now we have that shellnum is the shellIndex of the shell named ShellId >> 326 >> 327 // G4cout << " the index of the shell is: "<<shellNum<<G4endl; >> 328 >> 329 // But we have now to select two shells: one for the transition, >> 330 // and another for the auger emission. >> 331 307 G4int transitionLoopShellIndex = 0; 332 G4int transitionLoopShellIndex = 0; 308 G4double partSum = 0; 333 G4double partSum = 0; 309 const G4AugerTransition* anAugerTransiti 334 const G4AugerTransition* anAugerTransition = 310 transitionManager->ReachableAugerS 335 transitionManager->ReachableAugerShell(Z,shellNum); 311 336 312 G4int transitionSize = (G4int) << 337 // G4cout << " corresponding to the ID: "<< anAugerTransition->FinalShellId() << G4endl; >> 338 >> 339 >> 340 G4int transitionSize = 313 (anAugerTransition->TransitionOrig 341 (anAugerTransition->TransitionOriginatingShellIds())->size(); 314 while (transitionLoopShellIndex < transi 342 while (transitionLoopShellIndex < transitionSize) { 315 343 316 std::vector<G4int>::const_iterator pos 344 std::vector<G4int>::const_iterator pos = 317 anAugerTransition->TransitionOr 345 anAugerTransition->TransitionOriginatingShellIds()->begin(); 318 346 319 G4int transitionLoopShellId = *(pos+tr 347 G4int transitionLoopShellId = *(pos+transitionLoopShellIndex); 320 G4int numberOfPossibleAuger = (G4int) << 348 G4int numberOfPossibleAuger = 321 (anAugerTransition->AugerTransit 349 (anAugerTransition->AugerTransitionProbabilities(transitionLoopShellId))->size(); 322 G4int augerIndex = 0; 350 G4int augerIndex = 0; >> 351 // G4int partSum2 = 0; >> 352 323 353 324 if (augerIndex < numberOfPossibleAuger) { << 354 if (augerIndex < numberOfPossibleAuger) { >> 355 325 do 356 do 326 { 357 { 327 G4double thisProb = anAugerTransition- 358 G4double thisProb = anAugerTransition->AugerTransitionProbability(augerIndex, 328 transitionLoopShellId); 359 transitionLoopShellId); 329 partSum += thisProb; 360 partSum += thisProb; 330 augerIndex++; 361 augerIndex++; 331 362 332 } while (augerIndex < numberOfPossibleAu 363 } while (augerIndex < numberOfPossibleAuger); 333 } 364 } 334 transitionLoopShellIndex++; 365 transitionLoopShellIndex++; 335 } 366 } 336 367 337 368 >> 369 338 // Now we have the entire probability of 370 // Now we have the entire probability of an auger transition for the vacancy 339 // located in shellNum (index of shellId 371 // located in shellNum (index of shellId) >> 372 >> 373 // AM *********************** F I X E D **************************** AM >> 374 // Here we duplicate the previous loop, this time looking to the sum of the probabilities >> 375 // to be under the random number shoot by G4 UniformRdandom. This could have been done in the >> 376 // previuos loop, while integrating the probabilities. There is a bug that will be fixed >> 377 // 5 minutes from now: a line: >> 378 // G4int numberOfPossibleAuger = (anAugerTransition-> >> 379 // AugerTransitionProbabilities(transitionLoopShellId))->size(); >> 380 // to be inserted. >> 381 // AM *********************** F I X E D **************************** AM >> 382 >> 383 // Remains to get the same result with a single loop. >> 384 >> 385 // AM *********************** F I X E D **************************** AM >> 386 // Another Bug: in EADL Auger Transition are normalized to all the transitions deriving from >> 387 // a vacancy in one shell, but not all of these are present in data tables. So if a transition >> 388 // doesn't occur in the main one a local energy deposition must occur, instead of (like now) >> 389 // generating the last transition present in EADL data. >> 390 // AM *********************** F I X E D **************************** AM >> 391 >> 392 340 G4double totalVacancyAugerProbability = 393 G4double totalVacancyAugerProbability = partSum; 341 394 >> 395 342 //And now we start to select the right a 396 //And now we start to select the right auger transition and emission 343 G4int transitionRandomShellIndex = 0; 397 G4int transitionRandomShellIndex = 0; 344 G4int transitionRandomShellId = 1; 398 G4int transitionRandomShellId = 1; 345 G4int augerIndex = 0; 399 G4int augerIndex = 0; 346 partSum = 0; 400 partSum = 0; 347 G4double partialProb = G4UniformRand(); 401 G4double partialProb = G4UniformRand(); 348 // G4int augerOriginatingShellId = 0; 402 // G4int augerOriginatingShellId = 0; 349 403 350 G4int numberOfPossibleAuger = 0; 404 G4int numberOfPossibleAuger = 0; 351 405 352 G4bool foundFlag = false; 406 G4bool foundFlag = false; 353 407 354 while (transitionRandomShellIndex < tran 408 while (transitionRandomShellIndex < transitionSize) { >> 409 355 std::vector<G4int>::const_iterator pos 410 std::vector<G4int>::const_iterator pos = 356 anAugerTransition->TransitionOr 411 anAugerTransition->TransitionOriginatingShellIds()->begin(); 357 412 358 transitionRandomShellId = *(pos+transi 413 transitionRandomShellId = *(pos+transitionRandomShellIndex); 359 414 360 augerIndex = 0; 415 augerIndex = 0; 361 numberOfPossibleAuger = (G4int)(anAugerTrans << 416 numberOfPossibleAuger = (anAugerTransition-> 362 AugerTransitionProbabilities(transiti 417 AugerTransitionProbabilities(transitionRandomShellId))->size(); 363 418 364 while (augerIndex < numberOfPossibleAu 419 while (augerIndex < numberOfPossibleAuger) { 365 G4double thisProb =anAugerTransition->Auge 420 G4double thisProb =anAugerTransition->AugerTransitionProbability(augerIndex, 366 transitionRandomShellId); 421 transitionRandomShellId); 367 422 368 partSum += thisProb; 423 partSum += thisProb; 369 424 370 if (partSum >= (partialProb*totalVac 425 if (partSum >= (partialProb*totalVacancyAugerProbability) ) { // was / 371 foundFlag = true; 426 foundFlag = true; 372 break; 427 break; 373 } 428 } 374 augerIndex++; 429 augerIndex++; 375 } 430 } 376 if (partSum >= (partialProb*totalVacan 431 if (partSum >= (partialProb*totalVacancyAugerProbability) ) {break;} // was / 377 transitionRandomShellIndex++; 432 transitionRandomShellIndex++; 378 } 433 } 379 434 380 // Now we have the index of the shell fr 435 // Now we have the index of the shell from wich comes the auger electron (augerIndex), 381 // and the id of the shell, from which t 436 // and the id of the shell, from which the transition e- come (transitionRandomShellid) 382 // If no Transition has been found, 0 is 437 // If no Transition has been found, 0 is returned. 383 438 384 if (!foundFlag) {return 0;} 439 if (!foundFlag) {return 0;} 385 440 386 // Isotropic angular distribution for th 441 // Isotropic angular distribution for the outcoming e- 387 G4double newcosTh = 1.-2.*G4UniformRand( 442 G4double newcosTh = 1.-2.*G4UniformRand(); 388 G4double newsinTh = std::sqrt(1.-newcos 443 G4double newsinTh = std::sqrt(1.-newcosTh*newcosTh); 389 G4double newPhi = twopi*G4UniformRand(); 444 G4double newPhi = twopi*G4UniformRand(); 390 445 391 G4double xDir = newsinTh*std::sin(newPh 446 G4double xDir = newsinTh*std::sin(newPhi); 392 G4double yDir = newsinTh*std::cos(newPhi 447 G4double yDir = newsinTh*std::cos(newPhi); 393 G4double zDir = newcosTh; 448 G4double zDir = newcosTh; 394 449 395 G4ThreeVector newElectronDirection(xDir, 450 G4ThreeVector newElectronDirection(xDir,yDir,zDir); 396 451 397 // energy of the auger electron emitted 452 // energy of the auger electron emitted 398 << 453 >> 454 399 G4double transitionEnergy = anAugerTrans 455 G4double transitionEnergy = anAugerTransition->AugerTransitionEnergy(augerIndex, transitionRandomShellId); 400 /* 456 /* 401 G4cout << "AUger TransitionId " << anAugerTr 457 G4cout << "AUger TransitionId " << anAugerTransition->FinalShellId() << G4endl; 402 G4cout << "augerIndex: " << augerIndex << G4 458 G4cout << "augerIndex: " << augerIndex << G4endl; 403 G4cout << "transitionShellId: " << transitio 459 G4cout << "transitionShellId: " << transitionRandomShellId << G4endl; 404 */ 460 */ 405 461 406 // This is the shell where the new vacan 462 // This is the shell where the new vacancy is: it is the same 407 // shell where the electron came from 463 // shell where the electron came from 408 newShellId = transitionRandomShellId; 464 newShellId = transitionRandomShellId; 409 << 465 >> 466 410 G4DynamicParticle* newPart = new G4Dynam 467 G4DynamicParticle* newPart = new G4DynamicParticle(G4Electron::Electron(), 411 newElectronDirection, 468 newElectronDirection, 412 transitionEnergy); 469 transitionEnergy); 413 return newPart; 470 return newPart; >> 471 414 } 472 } 415 else 473 else 416 { 474 { 417 //G4Exception("G4AtomicDeexcitation: no 475 //G4Exception("G4AtomicDeexcitation: no auger transition found"); 418 return 0; 476 return 0; 419 } 477 } >> 478 420 } 479 } 421 480 422 void G4AtomicDeexcitation::SetCutForSecondaryP 481 void G4AtomicDeexcitation::SetCutForSecondaryPhotons(G4double cut) 423 { 482 { 424 minGammaEnergy = cut; 483 minGammaEnergy = cut; 425 } 484 } 426 485 427 void G4AtomicDeexcitation::SetCutForAugerElect 486 void G4AtomicDeexcitation::SetCutForAugerElectrons(G4double cut) 428 { 487 { 429 minElectronEnergy = cut; 488 minElectronEnergy = cut; 430 } 489 } 431 490 432 void G4AtomicDeexcitation::ActivateAugerElectr 491 void G4AtomicDeexcitation::ActivateAugerElectronProduction(G4bool val) 433 { 492 { 434 fAuger = val; 493 fAuger = val; 435 } 494 } 436 495 437 496 438 497 439 498 440 499 441 500 442 501 443 502