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