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 // $Id: G4UAtomicDeexcitation.cc,v 1.11 26 // 27 // 27 // ------------------------------------------- 28 // ------------------------------------------------------------------- 28 // 29 // 29 // Geant4 Class file 30 // Geant4 Class file 30 // 31 // 31 // Authors: Alfonso Mantero (Alfonso.Mantero@g 32 // Authors: Alfonso Mantero (Alfonso.Mantero@ge.infn.it) 32 // 33 // 33 // Created 22 April 2010 from old G4UAtomicDee 34 // Created 22 April 2010 from old G4UAtomicDeexcitation class 34 // 35 // 35 // Modified: 36 // Modified: 36 // --------- 37 // --------- 37 // 20 Oct 2011 Alf modified to take into acc 38 // 20 Oct 2011 Alf modified to take into account ECPSSR form Form Factor 38 // 03 Nov 2011 Alf Extended Empirical and Fo 39 // 03 Nov 2011 Alf Extended Empirical and Form Factor ionisation XS models 39 // out thei ranges with Anal 40 // out thei ranges with Analytical one. 40 // 07 Nov 2011 Alf Restored original ioniati 41 // 07 Nov 2011 Alf Restored original ioniation XS for alphas, 41 // letting scaled ones for o 42 // letting scaled ones for other ions. 42 // 20 Mar 2012 LP Register G4PenelopeIonisa 43 // 20 Mar 2012 LP Register G4PenelopeIonisationCrossSection 43 // 44 // 44 // ------------------------------------------- 45 // ------------------------------------------------------------------- 45 // 46 // 46 // Class description: 47 // Class description: 47 // Implementation of atomic deexcitation 48 // Implementation of atomic deexcitation 48 // 49 // 49 // ------------------------------------------- 50 // ------------------------------------------------------------------- 50 51 51 #include "G4UAtomicDeexcitation.hh" 52 #include "G4UAtomicDeexcitation.hh" 52 #include "G4PhysicalConstants.hh" 53 #include "G4PhysicalConstants.hh" 53 #include "G4SystemOfUnits.hh" 54 #include "G4SystemOfUnits.hh" 54 #include "Randomize.hh" 55 #include "Randomize.hh" 55 #include "G4Gamma.hh" 56 #include "G4Gamma.hh" 56 #include "G4AtomicTransitionManager.hh" 57 #include "G4AtomicTransitionManager.hh" 57 #include "G4FluoTransition.hh" 58 #include "G4FluoTransition.hh" 58 #include "G4Electron.hh" 59 #include "G4Electron.hh" 59 #include "G4Positron.hh" 60 #include "G4Positron.hh" 60 #include "G4Proton.hh" 61 #include "G4Proton.hh" 61 #include "G4Alpha.hh" 62 #include "G4Alpha.hh" 62 63 63 #include "G4teoCrossSection.hh" 64 #include "G4teoCrossSection.hh" 64 #include "G4empCrossSection.hh" 65 #include "G4empCrossSection.hh" 65 #include "G4PenelopeIonisationCrossSection.hh" 66 #include "G4PenelopeIonisationCrossSection.hh" 66 #include "G4LivermoreIonisationCrossSection.hh 67 #include "G4LivermoreIonisationCrossSection.hh" 67 #include "G4EmCorrections.hh" 68 #include "G4EmCorrections.hh" 68 #include "G4LossTableManager.hh" 69 #include "G4LossTableManager.hh" 69 #include "G4EmParameters.hh" << 70 #include "G4Material.hh" 70 #include "G4Material.hh" 71 #include "G4AtomicShells.hh" 71 #include "G4AtomicShells.hh" 72 72 73 using namespace std; 73 using namespace std; 74 74 75 //....oooOO0OOooo........oooOO0OOooo........oo << 76 << 77 G4UAtomicDeexcitation::G4UAtomicDeexcitation() 75 G4UAtomicDeexcitation::G4UAtomicDeexcitation(): 78 G4VAtomDeexcitation("UAtomDeexcitation"), 76 G4VAtomDeexcitation("UAtomDeexcitation"), 79 minGammaEnergy(DBL_MAX), 77 minGammaEnergy(DBL_MAX), 80 minElectronEnergy(DBL_MAX), 78 minElectronEnergy(DBL_MAX), 81 newShellId(-1) << 79 emcorr(0) 82 { 80 { 83 anaPIXEshellCS = nullptr; << 81 PIXEshellCS = 0; 84 PIXEshellCS = nullptr; << 82 ePIXEshellCS = 0; 85 ePIXEshellCS = nullptr; << 86 emcorr = G4LossTableManager::Instance()->EmC 83 emcorr = G4LossTableManager::Instance()->EmCorrections(); 87 theElectron = G4Electron::Electron(); 84 theElectron = G4Electron::Electron(); 88 thePositron = G4Positron::Positron(); 85 thePositron = G4Positron::Positron(); 89 transitionManager = G4AtomicTransitionManage << 86 transitionManager = 0; >> 87 anaPIXEshellCS = 0; 90 } 88 } 91 89 92 //....oooOO0OOooo........oooOO0OOooo........oo << 93 << 94 G4UAtomicDeexcitation::~G4UAtomicDeexcitation( 90 G4UAtomicDeexcitation::~G4UAtomicDeexcitation() 95 { 91 { 96 delete anaPIXEshellCS; << 97 delete PIXEshellCS; 92 delete PIXEshellCS; >> 93 delete anaPIXEshellCS; 98 delete ePIXEshellCS; 94 delete ePIXEshellCS; 99 } 95 } 100 96 101 //....oooOO0OOooo........oooOO0OOooo........oo << 102 << 103 void G4UAtomicDeexcitation::InitialiseForNewRu 97 void G4UAtomicDeexcitation::InitialiseForNewRun() 104 { 98 { 105 if(!IsFluoActive()) { return; } 99 if(!IsFluoActive()) { return; } 106 transitionManager->Initialise(); << 100 transitionManager = G4AtomicTransitionManager::Instance(); 107 if(!IsPIXEActive()) { return; } << 101 if(IsPIXEActive()) { 108 << 102 G4cout << G4endl; 109 if(!anaPIXEshellCS) { << 103 G4cout << "### === G4UAtomicDeexcitation::InitialiseForNewRun()" << G4endl; 110 anaPIXEshellCS = new G4teoCrossSection("EC << 104 anaPIXEshellCS = new G4teoCrossSection("Analytical"); >> 105 111 } 106 } 112 G4cout << G4endl; << 107 else {return;} 113 G4cout << "### === G4UAtomicDeexcitation::In << 108 // initializing PIXE x-section name 114 << 109 // 115 G4EmParameters* param = G4EmParameters::Inst << 110 if (PIXECrossSectionModel() == "" || 116 G4String namePIXExsModel = param->PIXECrossS << 111 PIXECrossSectionModel() == "Empirical" || 117 G4String namePIXExsElectronModel = param->PI << 112 PIXECrossSectionModel() == "empirical") 118 << 113 { 119 // Check if old cross section for p/ion shou << 114 SetPIXECrossSectionModel("Empirical"); 120 if(PIXEshellCS && namePIXExsModel != PIXEshe << 115 } >> 116 else if (PIXECrossSectionModel() == "ECPSSR_Analytical" || >> 117 PIXECrossSectionModel() == "Analytical" || >> 118 PIXECrossSectionModel() == "analytical") >> 119 { >> 120 SetPIXECrossSectionModel("Analytical"); >> 121 } >> 122 else if (PIXECrossSectionModel() == "ECPSSR_FormFactor" || >> 123 PIXECrossSectionModel() == "ECPSSR_Tabulated" || >> 124 PIXECrossSectionModel() == "Analytical_Tabulated") 121 { 125 { 122 delete PIXEshellCS; << 126 SetPIXECrossSectionModel("ECPSSR_FormFactor"); 123 PIXEshellCS = nullptr; << 127 } >> 128 else >> 129 { >> 130 G4cout << "### G4UAtomicDeexcitation::InitialiseForNewRun WARNING " >> 131 << G4endl; >> 132 G4cout << " PIXE cross section name " << PIXECrossSectionModel() >> 133 << " is unknown, Analytical cross section will be used" << G4endl; >> 134 SetPIXECrossSectionModel("Analytical"); >> 135 } >> 136 >> 137 // Check if old model should be deleted >> 138 if(PIXEshellCS) >> 139 { >> 140 if(PIXECrossSectionModel() != PIXEshellCS->GetName()) >> 141 { >> 142 delete PIXEshellCS; >> 143 PIXEshellCS = 0; >> 144 } 124 } 145 } 125 146 126 // Instantiate new proton/ion cross section << 147 // Instantiate empirical model 127 if(!PIXEshellCS) { 148 if(!PIXEshellCS) { 128 if (namePIXExsModel == "ECPSSR_FormFactor" << 149 if (PIXECrossSectionModel() == "Empirical") 129 { 150 { 130 PIXEshellCS = new G4teoCrossSection(namePIXE << 151 PIXEshellCS = new G4empCrossSection("Empirical"); 131 } 152 } 132 else if(namePIXExsModel == "ECPSSR_ANSTO") << 153 133 { << 154 if (PIXECrossSectionModel() == "ECPSSR_FormFactor") 134 PIXEshellCS = new G4teoCrossSection(namePIXE << 135 } << 136 else if(namePIXExsModel == "Empirical") << 137 { 155 { 138 PIXEshellCS = new G4empCrossSection(namePIXE << 156 PIXEshellCS = new G4teoCrossSection("ECPSSR_FormFactor"); 139 } 157 } 140 } 158 } 141 159 142 // Check if old cross section for e+- should << 160 // Electron cross section 143 if(ePIXEshellCS && namePIXExsElectronModel ! << 161 // initializing PIXE x-section name >> 162 // >> 163 if (PIXEElectronCrossSectionModel() == "" || >> 164 PIXEElectronCrossSectionModel() == "Livermore") 144 { 165 { 145 delete ePIXEshellCS; << 166 SetPIXEElectronCrossSectionModel("Livermore"); 146 ePIXEshellCS = nullptr; << 167 } 147 } << 168 else if (PIXEElectronCrossSectionModel() == "ProtonAnalytical" || >> 169 PIXEElectronCrossSectionModel() == "Analytical" || >> 170 PIXEElectronCrossSectionModel() == "analytical") >> 171 { >> 172 SetPIXEElectronCrossSectionModel("ProtonAnalytical"); >> 173 } >> 174 else if (PIXEElectronCrossSectionModel() == "ProtonEmpirical" || >> 175 PIXEElectronCrossSectionModel() == "Empirical" || >> 176 PIXEElectronCrossSectionModel() == "empirical") >> 177 { >> 178 SetPIXEElectronCrossSectionModel("ProtonEmpirical"); >> 179 } >> 180 else if (PIXEElectronCrossSectionModel() == "Penelope") >> 181 SetPIXEElectronCrossSectionModel("Penelope"); >> 182 else >> 183 { >> 184 G4cout << "### G4UAtomicDeexcitation::InitialiseForNewRun WARNING " >> 185 << G4endl; >> 186 G4cout << " PIXE e- cross section name " << PIXEElectronCrossSectionModel() >> 187 << " is unknown, PIXE is disabled" << G4endl; >> 188 SetPIXEElectronCrossSectionModel("Livermore"); >> 189 } >> 190 >> 191 // Check if old model should be deleted >> 192 if(ePIXEshellCS) >> 193 { >> 194 if(PIXEElectronCrossSectionModel() != ePIXEshellCS->GetName()) >> 195 { >> 196 delete ePIXEshellCS; >> 197 ePIXEshellCS = 0; >> 198 } >> 199 } 148 200 149 // Instantiate new e+- cross section << 201 // Instantiate empirical model 150 if(nullptr == ePIXEshellCS) << 202 if(!ePIXEshellCS) 151 { 203 { 152 if(namePIXExsElectronModel == "Empirical << 204 if(PIXEElectronCrossSectionModel() == "Empirical") 153 { 205 { 154 ePIXEshellCS = new G4empCrossSection("Empi 206 ePIXEshellCS = new G4empCrossSection("Empirical"); 155 } 207 } 156 else if(namePIXExsElectronModel == "ECPS << 208 >> 209 else if(PIXEElectronCrossSectionModel() == "Analytical") 157 { 210 { 158 ePIXEshellCS = new G4teoCrossSection("ECPS << 211 ePIXEshellCS = new G4teoCrossSection("Analytical"); 159 } 212 } 160 else if (namePIXExsElectronModel == "Pen << 213 >> 214 else if(PIXEElectronCrossSectionModel() == "Livermore") 161 { 215 { 162 ePIXEshellCS = new G4PenelopeIonisationCro << 216 ePIXEshellCS = new G4LivermoreIonisationCrossSection(); 163 } 217 } 164 else << 218 else if (PIXEElectronCrossSectionModel() == "Penelope") 165 { 219 { 166 ePIXEshellCS = new G4LivermoreIonisationCr << 220 ePIXEshellCS = new G4PenelopeIonisationCrossSection(); 167 } 221 } 168 } 222 } 169 } 223 } 170 224 171 //....oooOO0OOooo........oooOO0OOooo........oo << 225 void G4UAtomicDeexcitation::InitialiseForExtraAtom(G4int /*Z*/) 172 << 173 void G4UAtomicDeexcitation::InitialiseForExtra << 174 {} 226 {} 175 227 176 //....oooOO0OOooo........oooOO0OOooo........oo << 228 const G4AtomicShell* G4UAtomicDeexcitation::GetAtomicShell(G4int Z, G4AtomicShellEnumerator shell) 177 << 178 const G4AtomicShell* << 179 G4UAtomicDeexcitation::GetAtomicShell(G4int Z, << 180 { 229 { 181 return transitionManager->Shell(Z, (std::siz << 230 return transitionManager->Shell(Z, size_t(shell)); 182 } 231 } 183 232 184 //....oooOO0OOooo........oooOO0OOooo........oo << 185 << 186 void G4UAtomicDeexcitation::GenerateParticles( 233 void G4UAtomicDeexcitation::GenerateParticles( 187 std::vector<G4DynamicParticle* << 234 std::vector<G4DynamicParticle*>* vectorOfParticles, 188 const G4AtomicShell* atomicShell, << 235 const G4AtomicShell* atomicShell, 189 G4int Z, << 236 G4int Z, 190 G4double gammaCut, << 237 G4double gammaCut, 191 G4double eCut) << 238 G4double eCut) 192 { 239 { >> 240 193 // Defined initial conditions 241 // Defined initial conditions 194 G4int givenShellId = atomicShell->ShellId(); 242 G4int givenShellId = atomicShell->ShellId(); >> 243 //G4cout << "generating particles for vacancy in shellId: " << givenShellId << G4endl; // debug 195 minGammaEnergy = gammaCut; 244 minGammaEnergy = gammaCut; 196 minElectronEnergy = eCut; 245 minElectronEnergy = eCut; 197 vacancyArray.clear(); << 246 198 << 247 // V.I. short-cut >> 248 // if(!IsAugerActive()) { minElectronEnergy = DBL_MAX; } >> 249 199 // generation secondaries 250 // generation secondaries 200 G4DynamicParticle* aParticle=0; 251 G4DynamicParticle* aParticle=0; 201 G4int provShellId = 0; 252 G4int provShellId = 0; >> 253 G4int counter = 0; 202 254 203 //ORIGINAL METHOD BY ALFONSO MANTERO << 255 // let's check that 5<Z<100 204 if (!IsAugerCascadeActive()) << 205 { << 206 //---------------------------- << 207 G4int counter = 0; << 208 << 209 // limits of the EPDL data << 210 if (Z>5 && Z<105) { << 211 256 212 // The aim of this loop is to generate more << 257 if (Z>5 && Z<100) { 213 // from the same ionizing event << 258 214 do << 259 // The aim of this loop is to generate more than one fluorecence photon >> 260 // from the same ionizing event >> 261 do >> 262 { >> 263 if (counter == 0) >> 264 // First call to GenerateParticles(...): >> 265 // givenShellId is given by the process 215 { 266 { 216 if (counter == 0) << 267 provShellId = SelectTypeOfTransition(Z, givenShellId); 217 // First call to GenerateParticles(... << 268 218 // givenShellId is given by the proces << 269 if ( provShellId >0) 219 { 270 { 220 provShellId = SelectTypeOfTransition(Z, gi << 271 aParticle = GenerateFluorescence(Z,givenShellId,provShellId); 221 << 272 //if (aParticle != 0) { G4cout << "****FLUO!_1**** " << aParticle->GetParticleDefinition()->GetParticleType() << " " << aParticle->GetKineticEnergy()/keV << G4endl ;} //debug 222 if (provShellId >0) << 223 { << 224 aParticle = << 225 GenerateFluorescence(Z, givenShellId << 226 } << 227 else if (provShellId == -1) << 228 { << 229 aParticle = GenerateAuger(Z, givenShel << 230 } << 231 } 273 } 232 else << 274 else if ( provShellId == -1) 233 // Following calls to GenerateParticle << 234 // newShellId is given by GenerateFluo << 235 { 275 { 236 provShellId = SelectTypeOfTransition(Z,new << 276 // G4cout << "Try to generate Auger 1" << G4endl; //debug 237 if (provShellId >0) << 277 aParticle = GenerateAuger(Z, givenShellId); 238 { << 278 // if (aParticle != 0) { G4cout << "****AUGER!****" << G4endl;} //debug 239 aParticle = GenerateFluorescence(Z,new << 240 } << 241 else if ( provShellId == -1) << 242 { << 243 aParticle = GenerateAuger(Z, newShellI << 244 } << 245 } 279 } 246 ++counter; << 280 else 247 if (aParticle != 0) << 248 { 281 { 249 vectorOfParticles->push_back(aParticle); << 282 G4Exception("G4UAtomicDeexcitation::GenerateParticles()","de0002",JustWarning, "Energy deposited locally"); 250 } 283 } 251 else {provShellId = -2;} << 284 } 252 } << 285 else 253 while (provShellId > -2); << 286 // Following calls to GenerateParticles(...): 254 } << 287 // newShellId is given by GenerateFluorescence(...) 255 } // Auger cascade is not active << 288 { 256 << 289 provShellId = SelectTypeOfTransition(Z,newShellId); 257 //END OF ORIGINAL METHOD BY ALFONSO MANTERO << 290 if (provShellId >0) 258 //---------------------- << 291 { 259 << 292 aParticle = GenerateFluorescence(Z,newShellId,provShellId); 260 // NEW METHOD << 293 //if (aParticle != 0) { G4cout << "****FLUO!_2****" << aParticle->GetParticleDefinition()->GetParticleType() << " " << aParticle->GetKineticEnergy()/keV << G4endl;} //debug 261 // Auger cascade by Burkhant Suerfu on March << 294 } 262 if (IsAugerCascadeActive()) << 295 else if ( provShellId == -1) >> 296 { >> 297 // G4cout << "Try to generate Auger 2" << G4endl; //debug >> 298 aParticle = GenerateAuger(Z, newShellId); >> 299 // if (aParticle != 0) { G4cout << "****AUGER!****" << G4endl;} //debug >> 300 } >> 301 else >> 302 { >> 303 G4Exception("G4UAtomicDeexcitation::GenerateParticles()","de0002",JustWarning, "Energy deposited locally"); >> 304 } >> 305 } >> 306 counter++; >> 307 if (aParticle != 0) >> 308 { >> 309 vectorOfParticles->push_back(aParticle); >> 310 //G4cout << "Deexcitation Occurred!" << G4endl; //debug >> 311 } >> 312 else {provShellId = -2;} >> 313 } >> 314 while (provShellId > -2); >> 315 } >> 316 else 263 { 317 { 264 //---------------------- << 318 G4Exception("G4UAtomicDeexcitation::GenerateParticles()","de0001",JustWarning, "Energy deposited locally"); 265 vacancyArray.push_back(givenShellId); << 319 } 266 << 320 267 // let's check that 5<Z<100 << 321 //G4cout << "---------FATTO!---------" << G4endl; //debug 268 if (Z<6 || Z>104){ << 269 return; << 270 } << 271 << 272 // as long as there is vacancy to be fil << 273 while(!vacancyArray.empty()){ << 274 // prepare to process the last element, and << 275 givenShellId = vacancyArray[0]; << 276 provShellId = SelectTypeOfTransition(Z,given << 277 << 278 //G4cout<<"\n------ Atom Transition with Z: << 279 // <<givenShellId<<" & target:"<<provShel << 280 if(provShellId>0){ << 281 aParticle = GenerateFluorescence(Z,givenSh << 282 } << 283 else if(provShellId == -1){ << 284 aParticle = GenerateAuger(Z, givenShellId) << 285 } << 286 // if a particle is created, put it in the << 287 if(aParticle!=0) << 288 vectorOfParticles->push_back(aParticle); << 289 << 290 // one vacancy has been processed. Erase it << 291 vacancyArray.erase(vacancyArray.begin()); << 292 } << 293 //---------------------- << 294 //End of Auger cascade by Burkhant Suerf << 295 322 296 } // Auger cascade is active << 297 } 323 } 298 324 299 //....oooOO0OOooo........oooOO0OOooo........oo << 300 << 301 G4double 325 G4double 302 G4UAtomicDeexcitation::GetShellIonisationCross 326 G4UAtomicDeexcitation::GetShellIonisationCrossSectionPerAtom( 303 const G4ParticleDefinition* pdef, << 327 const G4ParticleDefinition* pdef, 304 G4int Z, << 328 G4int Z, 305 G4AtomicShellEnumerator shellEnum, << 329 G4AtomicShellEnumerator shellEnum, 306 G4double kineticEnergy, << 330 G4double kineticEnergy, 307 const G4Material* mat) << 331 const G4Material* mat) 308 { 332 { >> 333 309 // we must put a control on the shell that a 334 // we must put a control on the shell that are passed: 310 // some shells should not pass (line "0" or 335 // some shells should not pass (line "0" or "2") 311 336 312 // check atomic number 337 // check atomic number 313 G4double xsec = 0.0; 338 G4double xsec = 0.0; 314 if(Z > 93 || Z < 6 ) { return xsec; } //corr 339 if(Z > 93 || Z < 6 ) { return xsec; } //corrected by alf - Z<6 missing 315 G4int idx = G4int(shellEnum); 340 G4int idx = G4int(shellEnum); 316 if(idx >= G4AtomicShells::GetNumberOfShells( 341 if(idx >= G4AtomicShells::GetNumberOfShells(Z)) { return xsec; } 317 342 >> 343 // 318 if(pdef == theElectron || pdef == thePositro 344 if(pdef == theElectron || pdef == thePositron) { 319 xsec = ePIXEshellCS->CrossSection(Z,shellE 345 xsec = ePIXEshellCS->CrossSection(Z,shellEnum,kineticEnergy,0.0,mat); 320 return xsec; 346 return xsec; 321 } 347 } 322 348 323 G4double mass = pdef->GetPDGMass(); 349 G4double mass = pdef->GetPDGMass(); 324 G4double escaled = kineticEnergy; 350 G4double escaled = kineticEnergy; 325 G4double q2 = 0.0; 351 G4double q2 = 0.0; 326 352 327 // scaling to protons for all particles excl << 353 // scaling to protons 328 G4int pdg = pdef->GetPDGEncoding(); << 354 if ((pdef->GetParticleName() != "proton" && pdef->GetParticleName() != "alpha" ) ) 329 if (pdg != 2212 && pdg != 1000020040) << 355 { 330 { << 356 mass = proton_mass_c2; 331 mass = proton_mass_c2; << 357 escaled = kineticEnergy*mass/(pdef->GetPDGMass()); 332 escaled = kineticEnergy*mass/(pdef->GetP << 358 333 << 359 if(mat) { 334 if(mat) { << 360 q2 = emcorr->EffectiveChargeSquareRatio(pdef,mat,kineticEnergy); 335 q2 = emcorr->EffectiveChargeSquareRatio(pdef << 361 } else { 336 } else { << 362 G4double q = pdef->GetPDGCharge()/eplus; 337 G4double q = pdef->GetPDGCharge()/eplus; << 363 q2 = q*q; 338 q2 = q*q; << 339 } << 340 } 364 } 341 << 342 if(PIXEshellCS) { << 343 xsec = PIXEshellCS->CrossSection(Z,shellEn << 344 } 365 } 345 if(xsec < 1e-100) { << 366 >> 367 if(PIXEshellCS) { xsec = PIXEshellCS->CrossSection(Z,shellEnum,escaled,mass,mat); } >> 368 if(xsec < 1e-100) { >> 369 346 xsec = anaPIXEshellCS->CrossSection(Z,shel 370 xsec = anaPIXEshellCS->CrossSection(Z,shellEnum,escaled,mass,mat); >> 371 347 } 372 } 348 373 349 if (q2) {xsec *= q2;} 374 if (q2) {xsec *= q2;} 350 375 351 return xsec; 376 return xsec; 352 } 377 } 353 378 354 //....oooOO0OOooo........oooOO0OOooo........oo << 355 << 356 void G4UAtomicDeexcitation::SetCutForSecondary 379 void G4UAtomicDeexcitation::SetCutForSecondaryPhotons(G4double cut) 357 { 380 { 358 minGammaEnergy = cut; 381 minGammaEnergy = cut; 359 } 382 } 360 383 361 //....oooOO0OOooo........oooOO0OOooo........oo << 362 << 363 void G4UAtomicDeexcitation::SetCutForAugerElec 384 void G4UAtomicDeexcitation::SetCutForAugerElectrons(G4double cut) 364 { 385 { 365 minElectronEnergy = cut; 386 minElectronEnergy = cut; 366 } 387 } 367 388 368 //....oooOO0OOooo........oooOO0OOooo........oo << 389 G4double 369 << 390 G4UAtomicDeexcitation::ComputeShellIonisationCrossSectionPerAtom( 370 G4double G4UAtomicDeexcitation::ComputeShellIo << 391 const G4ParticleDefinition* p, 371 const G4ParticleDefinition* p, << 392 G4int Z, 372 G4int Z, << 393 G4AtomicShellEnumerator shell, 373 G4AtomicShellEnumerator shell, << 394 G4double kinE, 374 G4double kinE, << 395 const G4Material* mat) 375 const G4Material* mat) << 376 { 396 { 377 return GetShellIonisationCrossSectionPerAtom 397 return GetShellIonisationCrossSectionPerAtom(p,Z,shell,kinE,mat); 378 } 398 } 379 399 380 //....oooOO0OOooo........oooOO0OOooo........oo << 381 << 382 G4int G4UAtomicDeexcitation::SelectTypeOfTrans 400 G4int G4UAtomicDeexcitation::SelectTypeOfTransition(G4int Z, G4int shellId) 383 { 401 { 384 if (shellId <=0 ) { 402 if (shellId <=0 ) { >> 403 G4Exception("G4UAtomicDeexcitation::SelecttypeOfTransition()","de0002",JustWarning, "Energy deposited locally"); 385 return 0; 404 return 0; 386 } 405 } >> 406 //G4bool fluoTransitionFoundFlag = false; 387 407 388 G4int provShellId = -1; 408 G4int provShellId = -1; 389 G4int shellNum = 0; 409 G4int shellNum = 0; 390 G4int maxNumOfShells = transitionManager->Nu 410 G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z); 391 411 392 const G4FluoTransition* refShell = << 412 const G4FluoTransition* refShell = transitionManager->ReachableShell(Z,maxNumOfShells-1); 393 transitionManager->ReachableShell(Z,maxNum << 394 413 395 // This loop gives shellNum the value of the 414 // This loop gives shellNum the value of the index of shellId 396 // in the vector storing the list of the she 415 // in the vector storing the list of the shells reachable through 397 // a radiative transition 416 // a radiative transition 398 if ( shellId <= refShell->FinalShellId()) 417 if ( shellId <= refShell->FinalShellId()) 399 { 418 { 400 while (shellId != transitionManager->Rea 419 while (shellId != transitionManager->ReachableShell(Z,shellNum)->FinalShellId()) 401 { 420 { 402 if(shellNum ==maxNumOfShells-1) 421 if(shellNum ==maxNumOfShells-1) 403 { 422 { 404 break; 423 break; 405 } 424 } 406 shellNum++; 425 shellNum++; 407 } 426 } 408 G4int transProb = 0; //AM change 29/6/07 427 G4int transProb = 0; //AM change 29/6/07 was 1 409 428 410 G4double partialProb = G4UniformRand(); 429 G4double partialProb = G4UniformRand(); 411 G4double partSum = 0; 430 G4double partSum = 0; 412 const G4FluoTransition* aShell = transit << 431 const G4FluoTransition* aShell = transitionManager->ReachableShell(Z,shellNum); 413 G4int trSize = (G4int)(aShell->Transiti << 432 G4int trSize = (aShell->TransitionProbabilities()).size(); 414 433 415 // Loop over the shells wich can provide 434 // Loop over the shells wich can provide an electron for a 416 // radiative transition towards shellId: 435 // radiative transition towards shellId: 417 // in every loop the partial sum of the 436 // in every loop the partial sum of the first transProb shells 418 // is calculated and compared with a ran 437 // is calculated and compared with a random number [0,1]. 419 // If the partial sum is greater, the sh 438 // If the partial sum is greater, the shell whose index is transProb 420 // is chosen as the starting shell for a 439 // is chosen as the starting shell for a radiative transition 421 // and its identity is returned 440 // and its identity is returned 422 // Else, terminateded the loop, -1 is re 441 // Else, terminateded the loop, -1 is returned 423 while(transProb < trSize){ 442 while(transProb < trSize){ 424 partSum += aShell->TransitionProbability(tra << 443 >> 444 partSum += aShell->TransitionProbability(transProb); 425 445 426 if(partialProb <= partSum) << 446 if(partialProb <= partSum) 427 { << 447 { 428 provShellId = aShell->OriginatingShellId << 448 provShellId = aShell->OriginatingShellId(transProb); 429 break; << 449 //fluoTransitionFoundFlag = true; 430 } << 450 431 ++transProb; << 451 break; >> 452 } >> 453 transProb++; 432 } 454 } >> 455 433 // here provShellId is the right one or 456 // here provShellId is the right one or is -1. 434 // if -1, the control is passed to the A 457 // if -1, the control is passed to the Auger generation part of the package 435 } 458 } 436 else 459 else 437 { 460 { 438 provShellId = -1; 461 provShellId = -1; 439 } 462 } >> 463 //G4cout << "FlagTransition= " << provShellId << " ecut(MeV)= " << minElectronEnergy >> 464 // << " gcut(MeV)= " << minGammaEnergy << G4endl; 440 return provShellId; 465 return provShellId; 441 } 466 } 442 467 443 //....oooOO0OOooo........oooOO0OOooo........oo << 444 << 445 G4DynamicParticle* 468 G4DynamicParticle* 446 G4UAtomicDeexcitation::GenerateFluorescence(G4 469 G4UAtomicDeexcitation::GenerateFluorescence(G4int Z, G4int shellId, 447 G4int provShellId ) 470 G4int provShellId ) 448 { 471 { >> 472 >> 473 //if(!IsDeexActive()) { return 0; } >> 474 449 if (shellId <=0 ) 475 if (shellId <=0 ) >> 476 450 { 477 { 451 return nullptr; << 478 G4Exception("G4UAtomicDeexcitation::GenerateFluorescence()","de0002",JustWarning, "Energy deposited locally"); >> 479 return 0; 452 } 480 } >> 481 453 482 454 //isotropic angular distribution for the out 483 //isotropic angular distribution for the outcoming photon 455 G4double newcosTh = 1.-2.*G4UniformRand(); 484 G4double newcosTh = 1.-2.*G4UniformRand(); 456 G4double newsinTh = std::sqrt((1.-newcosTh)* 485 G4double newsinTh = std::sqrt((1.-newcosTh)*(1. + newcosTh)); 457 G4double newPhi = twopi*G4UniformRand(); 486 G4double newPhi = twopi*G4UniformRand(); 458 487 459 G4double xDir = newsinTh*std::sin(newPhi); 488 G4double xDir = newsinTh*std::sin(newPhi); 460 G4double yDir = newsinTh*std::cos(newPhi); 489 G4double yDir = newsinTh*std::cos(newPhi); 461 G4double zDir = newcosTh; 490 G4double zDir = newcosTh; 462 491 463 G4ThreeVector newGammaDirection(xDir,yDir,zD 492 G4ThreeVector newGammaDirection(xDir,yDir,zDir); 464 493 465 G4int shellNum = 0; 494 G4int shellNum = 0; 466 G4int maxNumOfShells = transitionManager->Nu 495 G4int maxNumOfShells = transitionManager->NumberOfReachableShells(Z); 467 496 468 // find the index of the shell named shellId 497 // find the index of the shell named shellId 469 while (shellId != transitionManager-> 498 while (shellId != transitionManager-> 470 ReachableShell(Z,shellNum)->FinalShellId()) 499 ReachableShell(Z,shellNum)->FinalShellId()) 471 { 500 { 472 if(shellNum == maxNumOfShells-1) 501 if(shellNum == maxNumOfShells-1) 473 { 502 { 474 break; 503 break; 475 } 504 } 476 ++shellNum; << 505 shellNum++; 477 } 506 } 478 // number of shell from wich an electron can 507 // number of shell from wich an electron can reach shellId 479 G4int transitionSize = (G4int)transitionMana << 508 size_t transitionSize = transitionManager-> 480 ReachableShell(Z,shellNum)->OriginatingShe 509 ReachableShell(Z,shellNum)->OriginatingShellIds().size(); 481 510 482 G4int index = 0; << 511 size_t index = 0; 483 512 484 // find the index of the shell named provShe 513 // find the index of the shell named provShellId in the vector 485 // storing the shells from which shellId can 514 // storing the shells from which shellId can be reached 486 while (provShellId != transitionManager-> 515 while (provShellId != transitionManager-> 487 ReachableShell(Z,shellNum)->OriginatingShel 516 ReachableShell(Z,shellNum)->OriginatingShellId(index)) 488 { 517 { 489 if(index == transitionSize-1) 518 if(index == transitionSize-1) 490 { 519 { 491 break; 520 break; 492 } 521 } 493 ++index; << 522 index++; 494 } 523 } 495 // energy of the gamma leaving provShellId f 524 // energy of the gamma leaving provShellId for shellId 496 G4double transitionEnergy = transitionManage 525 G4double transitionEnergy = transitionManager-> 497 ReachableShell(Z,shellNum)->TransitionEner 526 ReachableShell(Z,shellNum)->TransitionEnergy(index); 498 527 499 if (transitionEnergy < minGammaEnergy) retur << 528 if (transitionEnergy < minGammaEnergy) return 0; 500 529 501 // This is the shell where the new vacancy i 530 // This is the shell where the new vacancy is: it is the same 502 // shell where the electron came from 531 // shell where the electron came from 503 newShellId = transitionManager-> 532 newShellId = transitionManager-> 504 ReachableShell(Z,shellNum)->OriginatingShe 533 ReachableShell(Z,shellNum)->OriginatingShellId(index); 505 << 534 >> 535 506 G4DynamicParticle* newPart = new G4DynamicPa 536 G4DynamicParticle* newPart = new G4DynamicParticle(G4Gamma::Gamma(), 507 newGammaDirection, 537 newGammaDirection, 508 transitionEnergy); 538 transitionEnergy); 509 << 510 //Auger cascade by Burkhant Suerfu on March << 511 if (IsAugerCascadeActive()) vacancyArray.pus << 512 << 513 return newPart; 539 return newPart; 514 } 540 } 515 541 516 //....oooOO0OOooo........oooOO0OOooo........oo << 517 << 518 G4DynamicParticle* G4UAtomicDeexcitation::Gene 542 G4DynamicParticle* G4UAtomicDeexcitation::GenerateAuger(G4int Z, G4int shellId) 519 { 543 { 520 if(!IsAugerActive()) { 544 if(!IsAugerActive()) { 521 // G4cout << "auger inactive!" << G4end 545 // G4cout << "auger inactive!" << G4endl; //debug 522 return nullptr; << 546 return 0; 523 } 547 } 524 548 525 if (shellId <=0 ) { 549 if (shellId <=0 ) { 526 //G4Exception("G4UAtomicDeexcitation::Gene << 550 527 // JustWarning, "Energy deposited local << 551 528 return nullptr; << 552 G4Exception("G4UAtomicDeexcitation::GenerateAuger()","de0002",JustWarning, "Energy deposited locally"); >> 553 >> 554 return 0; >> 555 529 } 556 } 530 557 >> 558 // G4int provShellId = -1; 531 G4int maxNumOfShells = transitionManager->Nu 559 G4int maxNumOfShells = transitionManager->NumberOfReachableAugerShells(Z); 532 560 533 const G4AugerTransition* refAugerTransition 561 const G4AugerTransition* refAugerTransition = 534 transitionManager->ReachableAugerShell(Z,m << 562 transitionManager->ReachableAugerShell(Z,maxNumOfShells-1); 535 563 536 // This loop gives to shellNum the value of 564 // This loop gives to shellNum the value of the index of shellId 537 // in the vector storing the list of the vac 565 // in the vector storing the list of the vacancies in the variuos shells 538 // that can originate a NON-radiative transi 566 // that can originate a NON-radiative transition >> 567 539 G4int shellNum = 0; 568 G4int shellNum = 0; 540 << 569 541 if ( shellId <= refAugerTransition->FinalShe 570 if ( shellId <= refAugerTransition->FinalShellId() ) 542 // "FinalShellId" is final from the point << 571 //"FinalShellId" is final from the point of view of the elctron who makes the transition, 543 // who makes the transition, << 544 // being the Id of the shell in which ther 572 // being the Id of the shell in which there is a vacancy 545 { 573 { 546 G4int pippo = transitionManager->Reachab 574 G4int pippo = transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId(); 547 if (shellId != pippo ) { << 575 if (shellId != pippo ) { 548 do { 576 do { 549 ++shellNum; << 577 shellNum++; 550 if(shellNum == maxNumOfShells) 578 if(shellNum == maxNumOfShells) 551 { 579 { 552 // G4cout << "No Auger transition foun << 580 // G4cout << "No Auger transition found" << G4endl; //debug 553 return 0; 581 return 0; 554 } 582 } 555 } 583 } 556 while (shellId != (transitionManager->Reacha << 584 while (shellId != (transitionManager->ReachableAugerShell(Z,shellNum)->FinalShellId()) ) ; 557 } 585 } 558 586 >> 587 559 // Now we have that shellnum is the shel 588 // Now we have that shellnum is the shellIndex of the shell named ShellId >> 589 560 // G4cout << " the index of the she 590 // G4cout << " the index of the shell is: "<<shellNum<<G4endl; >> 591 561 // But we have now to select two shells: 592 // But we have now to select two shells: one for the transition, 562 // and another for the auger emission. 593 // and another for the auger emission. >> 594 563 G4int transitionLoopShellIndex = 0; 595 G4int transitionLoopShellIndex = 0; 564 G4double partSum = 0; 596 G4double partSum = 0; 565 const G4AugerTransition* anAugerTransiti 597 const G4AugerTransition* anAugerTransition = 566 transitionManager->ReachableAugerShell(Z,she << 598 transitionManager->ReachableAugerShell(Z,shellNum); >> 599 >> 600 // G4cout << " corresponding to the ID: "<< anAugerTransition->FinalShellId() << G4endl; 567 601 568 G4int transitionSize = (G4int) << 602 569 (anAugerTransition->TransitionOriginatingShe << 603 G4int transitionSize = >> 604 (anAugerTransition->TransitionOriginatingShellIds())->size(); 570 while (transitionLoopShellIndex < transi 605 while (transitionLoopShellIndex < transitionSize) { 571 606 572 std::vector<G4int>::const_iterator pos 607 std::vector<G4int>::const_iterator pos = 573 anAugerTransition->TransitionOriginatingSh << 608 anAugerTransition->TransitionOriginatingShellIds()->begin(); 574 609 575 G4int transitionLoopShellId = *(pos+tr 610 G4int transitionLoopShellId = *(pos+transitionLoopShellIndex); 576 G4int numberOfPossibleAuger = (G4int) << 611 G4int numberOfPossibleAuger = 577 (anAugerTransition->AugerTransitionProbabi << 612 (anAugerTransition->AugerTransitionProbabilities(transitionLoopShellId))->size(); 578 G4int augerIndex = 0; 613 G4int augerIndex = 0; 579 << 614 // G4int partSum2 = 0; >> 615 >> 616 580 if (augerIndex < numberOfPossibleAuger) { 617 if (augerIndex < numberOfPossibleAuger) { >> 618 581 do 619 do 582 { 620 { 583 G4double thisProb = anAugerTransition- 621 G4double thisProb = anAugerTransition->AugerTransitionProbability(augerIndex, 584 transitionLoopShellId); 622 transitionLoopShellId); 585 partSum += thisProb; 623 partSum += thisProb; 586 augerIndex++; 624 augerIndex++; 587 625 588 } while (augerIndex < numberOfPossibleAu 626 } while (augerIndex < numberOfPossibleAuger); 589 } << 627 } 590 ++transitionLoopShellIndex; << 628 transitionLoopShellIndex++; 591 } 629 } 592 << 630 >> 631 >> 632 >> 633 // Now we have the entire probability of an auger transition for the vacancy >> 634 // located in shellNum (index of shellId) >> 635 >> 636 // AM *********************** F I X E D **************************** AM >> 637 // Here we duplicate the previous loop, this time looking to the sum of the probabilities >> 638 // to be under the random number shoot by G4 UniformRdandom. This could have been done in the >> 639 // previuos loop, while integrating the probabilities. There is a bug that will be fixed >> 640 // 5 minutes from now: a line: >> 641 // G4int numberOfPossibleAuger = (anAugerTransition-> >> 642 // AugerTransitionProbabilities(transitionLoopShellId))->size(); >> 643 // to be inserted. >> 644 // AM *********************** F I X E D **************************** AM >> 645 >> 646 // Remains to get the same result with a single loop. >> 647 >> 648 // AM *********************** F I X E D **************************** AM >> 649 // Another Bug: in EADL Auger Transition are normalized to all the transitions deriving from >> 650 // a vacancy in one shell, but not all of these are present in data tables. So if a transition >> 651 // doesn't occur in the main one a local energy deposition must occur, instead of (like now) >> 652 // generating the last transition present in EADL data. >> 653 // AM *********************** F I X E D **************************** AM >> 654 >> 655 593 G4double totalVacancyAugerProbability = 656 G4double totalVacancyAugerProbability = partSum; 594 657 >> 658 595 //And now we start to select the right a 659 //And now we start to select the right auger transition and emission 596 G4int transitionRandomShellIndex = 0; 660 G4int transitionRandomShellIndex = 0; 597 G4int transitionRandomShellId = 1; 661 G4int transitionRandomShellId = 1; 598 G4int augerIndex = 0; 662 G4int augerIndex = 0; 599 partSum = 0; 663 partSum = 0; 600 G4double partialProb = G4UniformRand(); 664 G4double partialProb = G4UniformRand(); >> 665 // G4int augerOriginatingShellId = 0; >> 666 >> 667 G4int numberOfPossibleAuger = 0; 601 668 602 G4int numberOfPossibleAuger = 0; << 603 G4bool foundFlag = false; 669 G4bool foundFlag = false; 604 670 605 while (transitionRandomShellIndex < tran 671 while (transitionRandomShellIndex < transitionSize) { 606 672 607 std::vector<G4int>::const_iterator pos 673 std::vector<G4int>::const_iterator pos = 608 anAugerTransition->TransitionOriginatingSh << 674 anAugerTransition->TransitionOriginatingShellIds()->begin(); 609 675 610 transitionRandomShellId = *(pos+transi 676 transitionRandomShellId = *(pos+transitionRandomShellIndex); 611 677 612 augerIndex = 0; 678 augerIndex = 0; 613 numberOfPossibleAuger = (G4int)(anAugerTrans << 679 numberOfPossibleAuger = (anAugerTransition-> 614 AugerTransitionProbabilities(transiti 680 AugerTransitionProbabilities(transitionRandomShellId))->size(); 615 681 616 while (augerIndex < numberOfPossibleAu 682 while (augerIndex < numberOfPossibleAuger) { 617 G4double thisProb =anAugerTransition->Auge 683 G4double thisProb =anAugerTransition->AugerTransitionProbability(augerIndex, 618 transitionRandomShellId); 684 transitionRandomShellId); 619 685 620 partSum += thisProb; 686 partSum += thisProb; 621 687 622 if (partSum >= (partialProb*totalVac 688 if (partSum >= (partialProb*totalVacancyAugerProbability) ) { // was / 623 foundFlag = true; 689 foundFlag = true; 624 break; 690 break; 625 } 691 } 626 augerIndex++; 692 augerIndex++; 627 } 693 } 628 if (partSum >= (partialProb*totalVacan 694 if (partSum >= (partialProb*totalVacancyAugerProbability) ) {break;} // was / 629 ++transitionRandomShellIndex; << 695 transitionRandomShellIndex++; 630 } 696 } 631 697 632 // Now we have the index of the shell fr 698 // Now we have the index of the shell from wich comes the auger electron (augerIndex), 633 // and the id of the shell, from which t 699 // and the id of the shell, from which the transition e- come (transitionRandomShellid) 634 // If no Transition has been found, 0 is 700 // If no Transition has been found, 0 is returned. >> 701 635 if (!foundFlag) { 702 if (!foundFlag) { 636 return nullptr; << 703 // G4cout << "Auger not found (foundflag = false) " << G4endl; //debug 637 } << 704 return 0; >> 705 >> 706 } 638 707 639 // Isotropic angular distribution for th 708 // Isotropic angular distribution for the outcoming e- 640 G4double newcosTh = 1.-2.*G4UniformRand( 709 G4double newcosTh = 1.-2.*G4UniformRand(); 641 G4double newsinTh = std::sqrt(1.-newcosT << 710 G4double newsinTh = std::sqrt(1.-newcosTh*newcosTh); 642 G4double newPhi = twopi*G4UniformRand(); 711 G4double newPhi = twopi*G4UniformRand(); 643 712 644 G4double xDir = newsinTh*std::sin(newPhi << 713 G4double xDir = newsinTh*std::sin(newPhi); 645 G4double yDir = newsinTh*std::cos(newPhi 714 G4double yDir = newsinTh*std::cos(newPhi); 646 G4double zDir = newcosTh; 715 G4double zDir = newcosTh; 647 716 648 G4ThreeVector newElectronDirection(xDir, 717 G4ThreeVector newElectronDirection(xDir,yDir,zDir); 649 718 650 // energy of the auger electron emitted << 719 // energy of the auger electron emitted 651 G4double transitionEnergy = << 720 652 anAugerTransition->AugerTransitionEnergy(aug << 721 >> 722 G4double transitionEnergy = anAugerTransition->AugerTransitionEnergy(augerIndex, transitionRandomShellId); >> 723 /* >> 724 G4cout << "AUger TransitionId " << anAugerTransition->FinalShellId() << G4endl; >> 725 G4cout << "augerIndex: " << augerIndex << G4endl; >> 726 G4cout << "transitionShellId: " << transitionRandomShellId << G4endl; >> 727 */ 653 728 654 if (transitionEnergy < minElectronEnergy 729 if (transitionEnergy < minElectronEnergy) { 655 return nullptr; << 730 // G4cout << "Problem! (transitionEnergy < minElectronEnergy)" << G4endl; // debug >> 731 // G4cout << "minElectronEnergy(KeV): " << minElectronEnergy/keV << G4endl; // debug >> 732 // G4cout << "transitionEnergy(KeV): " << transitionEnergy/keV << G4endl; // debug >> 733 return 0; 656 } 734 } 657 735 658 // This is the shell where the new vacan 736 // This is the shell where the new vacancy is: it is the same 659 // shell where the electron came from 737 // shell where the electron came from 660 newShellId = transitionRandomShellId; 738 newShellId = transitionRandomShellId; 661 739 662 //Auger cascade by Burkhant Suerfu on Ma << 663 if (IsAugerCascadeActive()) << 664 { << 665 vacancyArray.push_back(newShellId); << 666 vacancyArray.push_back(anAugerTransition-> << 667 } << 668 << 669 return new G4DynamicParticle(G4Electron: 740 return new G4DynamicParticle(G4Electron::Electron(), 670 newElectronDirection, 741 newElectronDirection, 671 transitionEnergy); 742 transitionEnergy); 672 } 743 } 673 else 744 else 674 { 745 { 675 return nullptr; << 746 // G4cout << "G4UAtomicDeexcitation: no auger transition found" << G4endl ; >> 747 // G4cout << "( shellId <= refAugerTransition->FinalShellId() )" << G4endl; >> 748 return 0; 676 } 749 } 677 } 750 } 678 751