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: G4PAIxSection.cc,v 1.21 2006/06/29 19:53:20 gunter Exp $ >> 28 // GEANT4 tag $Name: geant4-08-03-patch-01 $ 27 // 29 // 28 // 30 // 29 // G4PAIxSection.cc -- class implementation fi 31 // G4PAIxSection.cc -- class implementation file 30 // 32 // 31 // GEANT 4 class implementation file 33 // GEANT 4 class implementation file 32 // 34 // 33 // For information related to this code, pleas 35 // For information related to this code, please, contact 34 // the Geant4 Collaboration. 36 // the Geant4 Collaboration. 35 // 37 // 36 // R&D: Vladimir.Grichine@cern.ch 38 // R&D: Vladimir.Grichine@cern.ch 37 // 39 // 38 // History: 40 // History: 39 // 41 // 40 // 13.05.03 V. Grichine, bug fixed for maxEner 42 // 13.05.03 V. Grichine, bug fixed for maxEnergyTransfer > max interval energy 41 // 28.05.01 V.Ivanchenko minor changes to prov 43 // 28.05.01 V.Ivanchenko minor changes to provide ANSI -wall compilation 42 // 17.05.01 V. Grichine, low energy extension 44 // 17.05.01 V. Grichine, low energy extension down to 10*keV of proton 43 // 20.11.98 adapted to a new Material/SandiaTa 45 // 20.11.98 adapted to a new Material/SandiaTable interface, mma 44 // 11.06.97 V. Grichine, 1st version 46 // 11.06.97 V. Grichine, 1st version 45 // 47 // 46 48 >> 49 >> 50 47 #include "G4PAIxSection.hh" 51 #include "G4PAIxSection.hh" 48 52 49 #include "globals.hh" 53 #include "globals.hh" 50 #include "G4PhysicalConstants.hh" << 51 #include "G4SystemOfUnits.hh" << 52 #include "G4ios.hh" 54 #include "G4ios.hh" 53 #include "G4Poisson.hh" 55 #include "G4Poisson.hh" 54 #include "G4Material.hh" 56 #include "G4Material.hh" 55 #include "G4MaterialCutsCouple.hh" 57 #include "G4MaterialCutsCouple.hh" 56 #include "G4SandiaTable.hh" 58 #include "G4SandiaTable.hh" 57 59 58 using namespace std; 60 using namespace std; 59 61 60 /* ******************************************* 62 /* ****************************************************************** 61 63 62 // Init array of Lorentz factors 64 // Init array of Lorentz factors 63 65 64 const G4double G4PAIxSection::fLorentzFactor[2 66 const G4double G4PAIxSection::fLorentzFactor[22] = 65 { 67 { 66 0.0 , 1.1 , 1.2 , 1.3 , 1 68 0.0 , 1.1 , 1.2 , 1.3 , 1.5 , 1.8 , 2.0 , 67 2.5 , 3.0 , 4.0 , 7.0 , 10 69 2.5 , 3.0 , 4.0 , 7.0 , 10.0 , 20.0 , 40.0 , 68 70.0 , 100.0 , 300.0 , 600.0 , 1000 70 70.0 , 100.0 , 300.0 , 600.0 , 1000.0 , 3000.0 , 69 10000.0 , 50000.0 71 10000.0 , 50000.0 70 }; << 72 } ; 71 73 72 const G4int G4PAIxSection:: 74 const G4int G4PAIxSection:: 73 fRefGammaNumber = 29; // The number of << 75 fRefGammaNumber = 29 ; // The number of gamma for creation of 74 // spline (9) 76 // spline (9) 75 77 76 ********************************************** 78 ***************************************************************** */ 77 79 78 // Local class constants 80 // Local class constants 79 81 80 const G4double G4PAIxSection::fDelta = 0.005; << 82 const G4double G4PAIxSection::fDelta = 0.005 ; // energy shift from interval border 81 const G4double G4PAIxSection::fError = 0.005; << 83 const G4double G4PAIxSection::fError = 0.005 ; // error in lin-log approximation 82 84 83 const G4int G4PAIxSection::fMaxSplineSize = 10 << 85 const G4int G4PAIxSection::fMaxSplineSize = 500 ; // Max size of output spline 84 86 // arrays 85 ////////////////////////////////////////////// << 86 // << 87 // Constructor << 88 // << 89 << 90 G4PAIxSection::G4PAIxSection() << 91 { << 92 fSandia = nullptr; << 93 fMatSandiaMatrix = nullptr; << 94 fDensity = fElectronDensity = fNormalization << 95 fIntervalNumber = fSplineNumber = 0; << 96 fVerbose = 0; << 97 << 98 fSplineEnergy = G4DataVector(fMaxSp << 99 fRePartDielectricConst = G4DataVector(fMaxSp << 100 fImPartDielectricConst = G4DataVector(fMaxSp << 101 fIntegralTerm = G4DataVector(fMaxSp << 102 fDifPAIxSection = G4DataVector(fMaxSp << 103 fdNdxCerenkov = G4DataVector(fMaxSp << 104 fdNdxPlasmon = G4DataVector(fMaxSp << 105 fdNdxMM = G4DataVector(fMaxSp << 106 fdNdxResonance = G4DataVector(fMaxSp << 107 fIntegralPAIxSection = G4DataVector(fMaxSp << 108 fIntegralPAIdEdx = G4DataVector(fMaxSp << 109 fIntegralCerenkov = G4DataVector(fMaxSp << 110 fIntegralPlasmon = G4DataVector(fMaxSp << 111 fIntegralMM = G4DataVector(fMaxSp << 112 fIntegralResonance = G4DataVector(fMaxSp << 113 << 114 fMaterialIndex = 0; << 115 << 116 for( G4int i = 0; i < 500; ++i ) << 117 { << 118 for( G4int j = 0; j < 112; ++j ) fPAItabl << 119 } << 120 } << 121 87 122 ////////////////////////////////////////////// 88 ////////////////////////////////////////////////////////////////// 123 // 89 // 124 // Constructor 90 // Constructor 125 // 91 // 126 92 127 G4PAIxSection::G4PAIxSection(G4MaterialCutsCou 93 G4PAIxSection::G4PAIxSection(G4MaterialCutsCouple* matCC) 128 { 94 { 129 fDensity = matCC->GetMaterial()->GetDe 95 fDensity = matCC->GetMaterial()->GetDensity(); 130 G4int matIndex = (G4int)matCC->GetMaterial() << 96 G4int matIndex = matCC->GetMaterial()->GetIndex(); 131 fMaterialIndex = matIndex; << 97 fSandia = new G4SandiaTable(matIndex); 132 << 133 const G4MaterialTable* theMaterialTable = G4 << 134 fSandia = (*theMaterialTable)[matIndex]->Get << 135 << 136 fVerbose = 0; << 137 98 138 G4int i, j; 99 G4int i, j; 139 fMatSandiaMatrix = new G4OrderedTable(); 100 fMatSandiaMatrix = new G4OrderedTable(); 140 101 141 for (i = 0; i < fSandia->GetMaxInterval()-1; << 102 for (i = 0; i < fSandia->GetMaxInterval()-1; i++) 142 { 103 { 143 fMatSandiaMatrix->push_back(new G4DataVec 104 fMatSandiaMatrix->push_back(new G4DataVector(5,0.)); 144 } << 105 } 145 for (i = 0; i < fSandia->GetMaxInterval()-1; << 106 for (i = 0; i < fSandia->GetMaxInterval()-1; i++) 146 { 107 { 147 (*(*fMatSandiaMatrix)[i])[0] = fSandia->Ge 108 (*(*fMatSandiaMatrix)[i])[0] = fSandia->GetSandiaMatTable(i,0); 148 109 149 for(j = 1; j < 5; ++j) << 110 for(j = 1; j < 5 ; j++) 150 { 111 { 151 (*(*fMatSandiaMatrix)[i])[j] = fSandia-> 112 (*(*fMatSandiaMatrix)[i])[j] = fSandia->GetSandiaMatTable(i,j)*fDensity; 152 } 113 } 153 } << 114 } 154 ComputeLowEnergyCof(); << 115 155 // fEnergyInterval = fA1 = fA2 = fA3 = fA4 << 156 } << 157 116 158 ////////////////////////////////////////////// << 117 >> 118 } 159 119 160 G4PAIxSection::G4PAIxSection(G4int materialInd 120 G4PAIxSection::G4PAIxSection(G4int materialIndex, 161 G4double maxEnerg << 121 G4double maxEnergyTransfer) 162 { 122 { 163 fSandia = nullptr; << 123 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable() ; 164 fMatSandiaMatrix = nullptr; << 124 G4int i, j ; 165 fVerbose = 0; << 166 const G4MaterialTable* theMaterialTable = G4 << 167 G4int i, j; << 168 << 169 fMaterialIndex = materialIndex; << 170 fDensity = (*theMaterialTable << 171 fElectronDensity = (*theMaterialTable << 172 GetElectronDensit << 173 fIntervalNumber = (*theMaterialTable << 174 GetSandiaTable()- << 175 fIntervalNumber--; << 176 // G4cout<<fDensity<<"\t"<<fElectronDensity< << 177 << 178 fEnergyInterval = G4DataVector(fIntervalNumb << 179 fA1 = G4DataVector(fIntervalNumb << 180 fA2 = G4DataVector(fIntervalNumb << 181 fA3 = G4DataVector(fIntervalNumb << 182 fA4 = G4DataVector(fIntervalNumb << 183 125 184 for(i = 1; i <= fIntervalNumber; i++ ) << 126 fDensity = (*theMaterialTable)[materialIndex]->GetDensity() ; 185 { << 127 fElectronDensity = (*theMaterialTable)[materialIndex]-> 186 if(((*theMaterialTable)[materialIndex]-> << 128 GetElectronDensity() ; >> 129 fIntervalNumber = (*theMaterialTable)[materialIndex]-> >> 130 GetSandiaTable()->GetMatNbOfIntervals() ; >> 131 fIntervalNumber--; >> 132 // G4cout<<fDensity<<"\t"<<fElectronDensity<<"\t"<<fIntervalNumber<<G4endl ; >> 133 >> 134 fEnergyInterval = new G4double[fIntervalNumber+2] ; >> 135 fA1 = new G4double[fIntervalNumber+2] ; >> 136 fA2 = new G4double[fIntervalNumber+2] ; >> 137 fA3 = new G4double[fIntervalNumber+2] ; >> 138 fA4 = new G4double[fIntervalNumber+2] ; >> 139 >> 140 for(i = 1 ; i <= fIntervalNumber ; i++ ) >> 141 { >> 142 if(((*theMaterialTable)[materialIndex]-> 187 GetSandiaTable()->GetSandiaCofForMaterial( 143 GetSandiaTable()->GetSandiaCofForMaterial(i-1,0) >= maxEnergyTransfer) || 188 i > fIntervalNumber 144 i > fIntervalNumber ) 189 { << 145 { 190 fEnergyInterval[i] = maxEnergyTransf << 146 fEnergyInterval[i] = maxEnergyTransfer ; 191 fIntervalNumber = i; << 147 fIntervalNumber = i ; 192 break; << 148 break; 193 } << 149 } 194 fEnergyInterval[i] = (*theMaterialTab 150 fEnergyInterval[i] = (*theMaterialTable)[materialIndex]-> 195 GetSandiaTable() << 151 GetSandiaTable()->GetSandiaCofForMaterial(i-1,0); 196 fA1[i] = (*theMaterialTab 152 fA1[i] = (*theMaterialTable)[materialIndex]-> 197 GetSandiaTable() << 153 GetSandiaTable()->GetSandiaCofForMaterial(i-1,1); 198 fA2[i] = (*theMaterialTab 154 fA2[i] = (*theMaterialTable)[materialIndex]-> 199 GetSandiaTable() << 155 GetSandiaTable()->GetSandiaCofForMaterial(i-1,2); 200 fA3[i] = (*theMaterialTab 156 fA3[i] = (*theMaterialTable)[materialIndex]-> 201 GetSandiaTable() << 157 GetSandiaTable()->GetSandiaCofForMaterial(i-1,3); 202 fA4[i] = (*theMaterialTab 158 fA4[i] = (*theMaterialTable)[materialIndex]-> 203 GetSandiaTable() << 159 GetSandiaTable()->GetSandiaCofForMaterial(i-1,4); 204 // G4cout<<i<<"\t"<<fEnergyInterval[i << 160 // G4cout<<i<<"\t"<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t" 205 // <<fA << 161 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl ; 206 } << 162 } 207 if(fEnergyInterval[fIntervalNumber] != maxEn << 163 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer) 208 { << 164 { 209 fIntervalNumber++; 165 fIntervalNumber++; 210 fEnergyInterval[fIntervalNumber] = ma << 166 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer ; 211 } << 167 } 212 168 213 // Now checking, if two borders are too clos << 169 // Now checking, if two borders are too close together 214 170 215 for(i=1;i<fIntervalNumber;i++) << 171 for(i=1;i<fIntervalNumber;i++) 216 { << 172 { 217 if(fEnergyInterval[i+1]-fEnergyInterva 173 if(fEnergyInterval[i+1]-fEnergyInterval[i] > 218 1.5*fDelta*(fEnergyInterval[i+1]+fE 174 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i])) 219 { << 175 { 220 continue; << 176 continue ; 221 } << 177 } 222 else 178 else 223 { << 179 { 224 for(j=i;j<fIntervalNumber;j++) 180 for(j=i;j<fIntervalNumber;j++) 225 { << 181 { 226 fEnergyInterval[j] = fEnergyInterv << 182 fEnergyInterval[j] = fEnergyInterval[j+1] ; 227 fA1[j] = fA1[j+1]; << 183 fA1[j] = fA1[j+1] ; 228 fA2[j] = fA2[j+1]; << 184 fA2[j] = fA2[j+1] ; 229 fA3[j] = fA3[j+1]; << 185 fA3[j] = fA3[j+1] ; 230 fA4[j] = fA4[j+1]; << 186 fA4[j] = fA4[j+1] ; 231 } << 187 } 232 fIntervalNumber--; << 188 fIntervalNumber-- ; 233 i--; << 189 i-- ; 234 } << 190 } 235 } << 191 } 236 192 237 193 238 /* ********************************* 194 /* ********************************* 239 195 240 fSplineEnergy = new G4double[fM << 196 fSplineEnergy = new G4double[fMaxSplineSize] ; 241 fRePartDielectricConst = new G4double[fM << 197 fRePartDielectricConst = new G4double[fMaxSplineSize] ; 242 fImPartDielectricConst = new G4double[fM << 198 fImPartDielectricConst = new G4double[fMaxSplineSize] ; 243 fIntegralTerm = new G4double[fM << 199 fIntegralTerm = new G4double[fMaxSplineSize] ; 244 fDifPAIxSection = new G4double[fM << 200 fDifPAIxSection = new G4double[fMaxSplineSize] ; 245 fIntegralPAIxSection = new G4double[fM << 201 fIntegralPAIxSection = new G4double[fMaxSplineSize] ; 246 202 247 for(i=0;i<fMaxSplineSize;i++) 203 for(i=0;i<fMaxSplineSize;i++) 248 { 204 { 249 fSplineEnergy[i] = 0.0; << 205 fSplineEnergy[i] = 0.0 ; 250 fRePartDielectricConst[i] = 0.0; << 206 fRePartDielectricConst[i] = 0.0 ; 251 fImPartDielectricConst[i] = 0.0; << 207 fImPartDielectricConst[i] = 0.0 ; 252 fIntegralTerm[i] = 0.0; << 208 fIntegralTerm[i] = 0.0 ; 253 fDifPAIxSection[i] = 0.0; << 209 fDifPAIxSection[i] = 0.0 ; 254 fIntegralPAIxSection[i] = 0.0; << 210 fIntegralPAIxSection[i] = 0.0 ; 255 } 211 } 256 **************************************** 212 ************************************************** */ 257 ComputeLowEnergyCof(); << 213 258 InitPAI(); // create arrays allocated a << 214 InitPAI() ; // create arrays allocated above 259 /* << 215 260 delete[] fEnergyInterval; << 216 delete[] fEnergyInterval ; 261 delete[] fA1; << 217 delete[] fA1 ; 262 delete[] fA2; << 218 delete[] fA2 ; 263 delete[] fA3; << 219 delete[] fA3 ; 264 delete[] fA4; << 220 delete[] fA4 ; 265 */ << 266 } 221 } 267 222 268 ////////////////////////////////////////////// 223 //////////////////////////////////////////////////////////////////////// 269 // 224 // 270 // Constructor called from G4PAIPhotonModel !! << 225 // Constructor with beta*gamma square value 271 226 272 G4PAIxSection::G4PAIxSection( G4int materialIn 227 G4PAIxSection::G4PAIxSection( G4int materialIndex, 273 G4double maxEner << 228 G4double maxEnergyTransfer, 274 G4double betaGam << 229 G4double betaGammaSq, 275 G4double** photo 230 G4double** photoAbsCof, 276 G4int intNumber 231 G4int intNumber ) 277 { 232 { 278 fSandia = nullptr; << 233 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable(); 279 fDensity = fElectronDensity = fNormalization << 234 G4int i, j ; 280 fIntervalNumber = fSplineNumber = 0; << 235 281 fVerbose = 0; << 236 fDensity = (*theMaterialTable)[materialIndex]->GetDensity(); 282 << 237 fElectronDensity = (*theMaterialTable)[materialIndex]-> 283 fSplineEnergy = G4DataVector(500,0. << 238 GetElectronDensity() ; 284 fRePartDielectricConst = G4DataVector(500,0. << 285 fImPartDielectricConst = G4DataVector(500,0. << 286 fIntegralTerm = G4DataVector(500,0. << 287 fDifPAIxSection = G4DataVector(500,0. << 288 fdNdxCerenkov = G4DataVector(500,0. << 289 fdNdxPlasmon = G4DataVector(500,0. << 290 fdNdxMM = G4DataVector(500,0. << 291 fdNdxResonance = G4DataVector(500,0. << 292 fIntegralPAIxSection = G4DataVector(500,0. << 293 fIntegralPAIdEdx = G4DataVector(500,0. << 294 fIntegralCerenkov = G4DataVector(500,0. << 295 fIntegralPlasmon = G4DataVector(500,0. << 296 fIntegralMM = G4DataVector(500,0. << 297 fIntegralResonance = G4DataVector(500,0. << 298 << 299 for( G4int i = 0; i < 500; ++i ) << 300 { << 301 for( G4int j = 0; j < 112; ++j ) fPAItabl << 302 } << 303 239 304 fSandia = nullptr; << 240 fIntervalNumber = intNumber ; 305 fMatSandiaMatrix = nullptr; << 241 fIntervalNumber--; 306 const G4MaterialTable* theMaterialTable = G4 << 242 // G4cout<<fDensity<<"\t"<<fElectronDensity<<"\t"<<fIntervalNumber<<G4endl ; 307 G4int i, j; << 308 << 309 fMaterialIndex = materialIndex; << 310 fDensity = (*theMaterialTable)[mater << 311 fElectronDensity = (*theMaterialTable)[mater << 312 << 313 fIntervalNumber = intNumber; << 314 fIntervalNumber--; << 315 // G4cout<<fDensity<<"\t"<<fElectronDensit << 316 243 317 fEnergyInterval = G4DataVector(fIntervalNumb << 244 fEnergyInterval = new G4double[fIntervalNumber+2] ; 318 fA1 = G4DataVector(fIntervalNumb << 245 fA1 = new G4double[fIntervalNumber+2] ; 319 fA2 = G4DataVector(fIntervalNumb << 246 fA2 = new G4double[fIntervalNumber+2] ; 320 fA3 = G4DataVector(fIntervalNumb << 247 fA3 = new G4double[fIntervalNumber+2] ; 321 fA4 = G4DataVector(fIntervalNumb << 248 fA4 = new G4double[fIntervalNumber+2] ; 322 << 323 249 324 /* << 250 for( i = 1 ; i <= fIntervalNumber ; i++ ) 325 fEnergyInterval = new G4double[fInterval << 251 { 326 fA1 = new G4double[fInterval << 327 fA2 = new G4double[fInterval << 328 fA3 = new G4double[fInterval << 329 fA4 = new G4double[fInterval << 330 */ << 331 for( i = 1; i <= fIntervalNumber; i++ ) << 332 { << 333 if( ( photoAbsCof[i-1][0] >= maxEnerg 252 if( ( photoAbsCof[i-1][0] >= maxEnergyTransfer ) || 334 i > fIntervalNumber ) 253 i > fIntervalNumber ) 335 { 254 { 336 fEnergyInterval[i] = maxEnergyTran << 255 fEnergyInterval[i] = maxEnergyTransfer ; 337 fIntervalNumber = i; << 256 fIntervalNumber = i ; 338 break; << 257 break; 339 } 258 } 340 fEnergyInterval[i] = photoAbsCof[i-1] << 259 fEnergyInterval[i] = photoAbsCof[i-1][0] ; 341 fA1[i] = photoAbsCof[i-1] << 260 fA1[i] = photoAbsCof[i-1][1] ; 342 fA2[i] = photoAbsCof[i-1] << 261 fA2[i] = photoAbsCof[i-1][2] ; 343 fA3[i] = photoAbsCof[i-1] << 262 fA3[i] = photoAbsCof[i-1][3] ; 344 fA4[i] = photoAbsCof[i-1] << 263 fA4[i] = photoAbsCof[i-1][4] ; 345 // G4cout<<i<<"\t"<<fEnergyInterval[i << 264 // G4cout<<i<<"\t"<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t" 346 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"< << 265 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl ; 347 } << 266 } 348 // G4cout<<"i last = "<<i<<"; "<<"fInter << 267 // G4cout<<"i last = "<<i<<"; "<<"fIntervalNumber = "<<fIntervalNumber<<G4endl; 349 << 268 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer) 350 if(fEnergyInterval[fIntervalNumber] != maxEn << 269 { 351 { << 352 fIntervalNumber++; 270 fIntervalNumber++; 353 fEnergyInterval[fIntervalNumber] = ma << 271 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer ; 354 } << 272 } 355 // G4cout<<"after check of max energy tr << 273 for(i=1;i<=fIntervalNumber;i++) 356 << 274 { 357 for( i = 1; i <= fIntervalNumber; i++ ) << 275 // G4cout<<i<<"\t"<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t" 358 { << 276 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl ; 359 // G4cout<<i<<"\t"<<fEnergyInterval[i] << 277 } 360 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4e << 361 } << 362 // Now checking, if two borders are too 278 // Now checking, if two borders are too close together 363 279 364 for( i = 1; i < fIntervalNumber; i++ ) << 280 for( i = 1 ; i < fIntervalNumber ; i++ ) 365 { << 281 { 366 if(fEnergyInterval[i+1]-fEnergyInterva 282 if(fEnergyInterval[i+1]-fEnergyInterval[i] > 367 1.5*fDelta*(fEnergyInterval[i+1]+fE 283 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i])) 368 { << 284 { 369 continue; << 285 continue ; 370 } << 286 } 371 else 287 else 372 { << 288 { 373 for(j=i;j<fIntervalNumber;j++) 289 for(j=i;j<fIntervalNumber;j++) 374 { << 290 { 375 fEnergyInterval[j] = fEnergyInterv << 291 fEnergyInterval[j] = fEnergyInterval[j+1] ; 376 fA1[j] = fA1[j+1]; << 292 fA1[j] = fA1[j+1] ; 377 fA2[j] = fA2[j+1]; << 293 fA2[j] = fA2[j+1] ; 378 fA3[j] = fA3[j+1]; << 294 fA3[j] = fA3[j+1] ; 379 fA4[j] = fA4[j+1]; << 295 fA4[j] = fA4[j+1] ; 380 } << 296 } 381 fIntervalNumber--; << 297 fIntervalNumber-- ; 382 i--; << 298 i-- ; 383 } << 299 } 384 } << 300 } 385 // G4cout<<"after check of close borders"<<G << 386 << 387 for( i = 1; i <= fIntervalNumber; i++ ) << 388 { << 389 // G4cout<<i<<"\t"<<fEnergyInterval[i] << 390 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4en << 391 } << 392 << 393 // Preparation of fSplineEnergy array corres << 394 301 395 ComputeLowEnergyCof(); << 302 // Preparation of fSplineEnergy array corresponding to min ionisation, G~4 396 G4double betaGammaSqRef = << 303 397 fLorentzFactor[fRefGammaNumber]*fLorentzFa << 304 G4double betaGammaSqRef = >> 305 fLorentzFactor[fRefGammaNumber]*fLorentzFactor[fRefGammaNumber] - 1; 398 306 399 NormShift(betaGammaSqRef); << 307 NormShift(betaGammaSqRef) ; 400 SplainPAI(betaGammaSqRef); << 308 SplainPAI(betaGammaSqRef) ; 401 309 402 // Preparation of integral PAI cross section << 310 // Preparation of integral PAI cross section for input betaGammaSq 403 311 404 for(i = 1; i <= fSplineNumber; i++) << 312 for(i = 1 ; i <= fSplineNumber ; i++) 405 { << 313 { 406 fdNdxCerenkov[i] = PAIdNdxCerenkov( 314 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq); 407 fdNdxMM[i] = PAIdNdxMM(i,betaGammaS << 408 fdNdxPlasmon[i] = PAIdNdxPlasmon(i 315 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq); 409 fdNdxResonance[i] = PAIdNdxResonance << 410 fDifPAIxSection[i] = DifPAIxSection(i 316 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq); 411 << 317 // G4cout<<i<<"; dNdxC = "<<fdNdxCerenkov[i]<<"; dNdxP = "<<fdNdxPlasmon[i] 412 // G4cout<<i<<"; dNdxC = "<<fdNdxCere << 318 // <<"; dNdxPAI = "<<fDifPAIxSection[i]<<G4endl; 413 // <<"; dNdxPAI = "<<fDifPAIxSecti << 319 } 414 } << 320 IntegralCerenkov() ; 415 IntegralCerenkov(); << 321 IntegralPlasmon() ; 416 IntegralMM(); << 322 IntegralPAIxSection() ; 417 IntegralPlasmon(); << 323 418 IntegralResonance(); << 324 delete[] fEnergyInterval ; 419 IntegralPAIxSection(); << 325 delete[] fA1 ; 420 /* << 326 delete[] fA2 ; 421 delete[] fEnergyInterval; << 327 delete[] fA3 ; 422 delete[] fA1; << 328 delete[] fA4 ; 423 delete[] fA2; << 424 delete[] fA3; << 425 delete[] fA4; << 426 */ << 427 } 329 } 428 330 429 ////////////////////////////////////////////// 331 //////////////////////////////////////////////////////////////////////// 430 // 332 // 431 // Test Constructor with beta*gamma square val 333 // Test Constructor with beta*gamma square value 432 334 433 G4PAIxSection::G4PAIxSection( G4int materialIn 335 G4PAIxSection::G4PAIxSection( G4int materialIndex, 434 G4double maxEner << 336 G4double maxEnergyTransfer, 435 G4double betaGam << 337 G4double betaGammaSq ) 436 { 338 { 437 fSandia = nullptr; << 339 const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable(); 438 fMatSandiaMatrix = nullptr; << 439 fVerbose = 0; << 440 const G4MaterialTable* theMaterialTable = G4 << 441 << 442 G4int i, j, numberOfElements; << 443 340 444 fMaterialIndex = materialIndex; << 341 G4int i, j, numberOfElements ; 445 fDensity = (*theMaterialTable)[mater << 342 446 fElectronDensity = (*theMaterialTable)[mater << 343 fDensity = (*theMaterialTable)[materialIndex]->GetDensity(); 447 numberOfElements = (G4int)(*theMaterialTable << 344 fElectronDensity = (*theMaterialTable)[materialIndex]->GetElectronDensity() ; >> 345 numberOfElements = (*theMaterialTable)[materialIndex]->GetNumberOfElements() ; 448 346 449 G4int* thisMaterialZ = new G4int[numberOfEle << 347 G4int* thisMaterialZ = new G4int[numberOfElements] ; 450 348 451 for( i = 0; i < numberOfElements; ++i ) << 349 for( i = 0 ; i < numberOfElements ; i++ ) 452 { 350 { 453 thisMaterialZ[i] = (G4int)(*theMateri 351 thisMaterialZ[i] = (G4int)(*theMaterialTable)[materialIndex]-> 454 GetEleme << 352 GetElement(i)->GetZ() ; 455 } 353 } 456 // fSandia = new G4SandiaTable(materialIndex << 354 G4SandiaTable thisMaterialSandiaTable(materialIndex) ; 457 fSandia = (*theMaterialTable)[materialIndex] << 355 fIntervalNumber = thisMaterialSandiaTable.SandiaIntervals 458 G4SandiaTable thisMaterialSandiaTable(ma << 356 (thisMaterialZ,numberOfElements) ; 459 fIntervalNumber = thisMaterialSandiaTable.Sa << 357 fIntervalNumber = thisMaterialSandiaTable.SandiaMixing 460 << 461 fIntervalNumber = thisMaterialSandiaTable.Sa << 462 ( thisMaterialZ , 358 ( thisMaterialZ , 463 (*theMaterialTable)[mate 359 (*theMaterialTable)[materialIndex]->GetFractionVector() , 464 numberOfElements, << 360 numberOfElements,fIntervalNumber) ; 465 361 466 fIntervalNumber--; << 362 fIntervalNumber--; 467 363 468 fEnergyInterval = G4DataVector(fIntervalNumb << 364 fEnergyInterval = new G4double[fIntervalNumber+2] ; 469 fA1 = G4DataVector(fIntervalNumb << 365 fA1 = new G4double[fIntervalNumber+2] ; 470 fA2 = G4DataVector(fIntervalNumb << 366 fA2 = new G4double[fIntervalNumber+2] ; 471 fA3 = G4DataVector(fIntervalNumb << 367 fA3 = new G4double[fIntervalNumber+2] ; 472 fA4 = G4DataVector(fIntervalNumb << 368 fA4 = new G4double[fIntervalNumber+2] ; 473 << 369 474 /* << 370 for(i=1;i<=fIntervalNumber;i++) 475 fEnergyInterval = new G4double[fInterval << 371 { 476 fA1 = new G4double[fInterval << 477 fA2 = new G4double[fInterval << 478 fA3 = new G4double[fInterval << 479 fA4 = new G4double[fInterval << 480 */ << 481 for( i = 1; i <= fIntervalNumber; i++ ) << 482 { << 483 if((thisMaterialSandiaTable.GetPhotoAbsorpCo 372 if((thisMaterialSandiaTable.GetPhotoAbsorpCof(i,0) >= maxEnergyTransfer) || 484 i > fIntervalNumber) 373 i > fIntervalNumber) 485 { 374 { 486 fEnergyInterval[i] = maxEnergyTran << 375 fEnergyInterval[i] = maxEnergyTransfer ; 487 fIntervalNumber = i; << 376 fIntervalNumber = i ; 488 break; << 377 break; 489 } 378 } 490 fEnergyInterval[i] = thisMaterialSandiaTabl << 379 fEnergyInterval[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,0) ; 491 fA1[i] = thisMaterialSandiaTabl << 380 fA1[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,1)*fDensity ; 492 fA2[i] = thisMaterialSandiaTabl << 381 fA2[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,2)*fDensity ; 493 fA3[i] = thisMaterialSandiaTabl << 382 fA3[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,3)*fDensity ; 494 fA4[i] = thisMaterialSandiaTabl << 383 fA4[i] = thisMaterialSandiaTable.GetPhotoAbsorpCof(i,4)*fDensity ; 495 384 496 } << 385 } 497 if(fEnergyInterval[fIntervalNumber] != maxEn << 386 if(fEnergyInterval[fIntervalNumber] != maxEnergyTransfer) 498 { << 387 { 499 fIntervalNumber++; 388 fIntervalNumber++; 500 fEnergyInterval[fIntervalNumber] = ma << 389 fEnergyInterval[fIntervalNumber] = maxEnergyTransfer ; 501 fA1[fIntervalNumber] = fA1[fIntervalN << 390 fA1[fIntervalNumber] = fA1[fIntervalNumber-1] ; 502 fA2[fIntervalNumber] = fA2[fIntervalN << 391 fA2[fIntervalNumber] = fA2[fIntervalNumber-1] ; 503 fA3[fIntervalNumber] = fA3[fIntervalN << 392 fA3[fIntervalNumber] = fA3[fIntervalNumber-1] ; 504 fA4[fIntervalNumber] = fA4[fIntervalN << 393 fA4[fIntervalNumber] = fA4[fIntervalNumber-1] ; 505 } << 394 } 506 for(i=1;i<=fIntervalNumber;i++) << 395 for(i=1;i<=fIntervalNumber;i++) 507 { << 396 { 508 // G4cout<<fEnergyInterval[i]<<"\t"<<f << 397 // G4cout<<fEnergyInterval[i]<<"\t"<<fA1[i]<<"\t"<<fA2[i]<<"\t" 509 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4e << 398 // <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl ; 510 } << 399 } 511 // Now checking, if two borders are too clos << 400 // Now checking, if two borders are too close together 512 401 513 for( i = 1; i < fIntervalNumber; i++ ) << 402 for(i=1;i<fIntervalNumber;i++) 514 { << 403 { 515 if(fEnergyInterval[i+1]-fEnergyInterva 404 if(fEnergyInterval[i+1]-fEnergyInterval[i] > 516 1.5*fDelta*(fEnergyInterval[i+1]+fE 405 1.5*fDelta*(fEnergyInterval[i+1]+fEnergyInterval[i])) 517 { << 406 { 518 continue; << 407 continue ; 519 } << 408 } 520 else 409 else 521 { << 410 { 522 for( j = i; j < fIntervalNumber; j++ << 411 for(j=i;j<fIntervalNumber;j++) 523 { << 412 { 524 fEnergyInterval[j] = fEnergyInterv << 413 fEnergyInterval[j] = fEnergyInterval[j+1] ; 525 fA1[j] = fA1[j+1]; << 414 fA1[j] = fA1[j+1] ; 526 fA2[j] = fA2[j+1]; << 415 fA2[j] = fA2[j+1] ; 527 fA3[j] = fA3[j+1]; << 416 fA3[j] = fA3[j+1] ; 528 fA4[j] = fA4[j+1]; << 417 fA4[j] = fA4[j+1] ; 529 } << 418 } 530 fIntervalNumber--; << 419 fIntervalNumber-- ; 531 i--; << 420 i-- ; 532 } << 421 } 533 } << 422 } 534 423 535 /* ********************************* 424 /* ********************************* 536 fSplineEnergy = new G4double[fM << 425 fSplineEnergy = new G4double[fMaxSplineSize] ; 537 fRePartDielectricConst = new G4double[fM << 426 fRePartDielectricConst = new G4double[fMaxSplineSize] ; 538 fImPartDielectricConst = new G4double[fM << 427 fImPartDielectricConst = new G4double[fMaxSplineSize] ; 539 fIntegralTerm = new G4double[fM << 428 fIntegralTerm = new G4double[fMaxSplineSize] ; 540 fDifPAIxSection = new G4double[fM << 429 fDifPAIxSection = new G4double[fMaxSplineSize] ; 541 fIntegralPAIxSection = new G4double[fM << 430 fIntegralPAIxSection = new G4double[fMaxSplineSize] ; 542 431 543 for(i=0;i<fMaxSplineSize;i++) 432 for(i=0;i<fMaxSplineSize;i++) 544 { 433 { 545 fSplineEnergy[i] = 0.0; << 434 fSplineEnergy[i] = 0.0 ; 546 fRePartDielectricConst[i] = 0.0; << 435 fRePartDielectricConst[i] = 0.0 ; 547 fImPartDielectricConst[i] = 0.0; << 436 fImPartDielectricConst[i] = 0.0 ; 548 fIntegralTerm[i] = 0.0; << 437 fIntegralTerm[i] = 0.0 ; 549 fDifPAIxSection[i] = 0.0; << 438 fDifPAIxSection[i] = 0.0 ; 550 fIntegralPAIxSection[i] = 0.0; << 439 fIntegralPAIxSection[i] = 0.0 ; 551 } 440 } 552 */ //////////////////////// 441 */ //////////////////////// 553 442 554 // Preparation of fSplineEnergy array co 443 // Preparation of fSplineEnergy array corresponding to min ionisation, G~4 >> 444 >> 445 G4double betaGammaSqRef = >> 446 fLorentzFactor[fRefGammaNumber]*fLorentzFactor[fRefGammaNumber] - 1; 555 447 556 ComputeLowEnergyCof(); << 448 NormShift(betaGammaSqRef) ; 557 G4double betaGammaSqRef = << 449 SplainPAI(betaGammaSqRef) ; 558 fLorentzFactor[fRefGammaNumber]*fLorentzFa << 559 << 560 NormShift(betaGammaSqRef); << 561 SplainPAI(betaGammaSqRef); << 562 450 563 // Preparation of integral PAI cross section << 451 // Preparation of integral PAI cross section for input betaGammaSq 564 452 565 for(i = 1; i <= fSplineNumber; i++) << 453 for(i = 1 ; i <= fSplineNumber ; i++) 566 { << 454 { 567 fDifPAIxSection[i] = DifPAIxSection(i 455 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq); 568 fdNdxCerenkov[i] = PAIdNdxCerenkov( 456 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq); 569 fdNdxMM[i] = PAIdNdxMM(i,betaGammaS << 570 fdNdxPlasmon[i] = PAIdNdxPlasmon(i 457 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq); 571 fdNdxResonance[i] = PAIdNdxResonance << 458 } 572 } << 459 IntegralPAIxSection() ; 573 IntegralPAIxSection(); << 460 IntegralCerenkov() ; 574 IntegralCerenkov(); << 461 IntegralPlasmon() ; 575 IntegralMM(); << 462 576 IntegralPlasmon(); << 463 // delete[] fEnergyInterval ; 577 IntegralResonance(); << 464 delete[] fA1 ; >> 465 delete[] fA2 ; >> 466 delete[] fA3 ; >> 467 delete[] fA4 ; 578 } 468 } 579 469 >> 470 580 ////////////////////////////////////////////// 471 //////////////////////////////////////////////////////////////////////////// 581 // 472 // 582 // Destructor 473 // Destructor 583 474 584 G4PAIxSection::~G4PAIxSection() 475 G4PAIxSection::~G4PAIxSection() 585 { 476 { 586 /* ************************ 477 /* ************************ 587 delete[] fSplineEnergy ; << 478 delete[] fSplineEnergy ; 588 delete[] fRePartDielectricConst; << 479 delete[] fRePartDielectricConst ; 589 delete[] fImPartDielectricConst; << 480 delete[] fImPartDielectricConst ; 590 delete[] fIntegralTerm ; << 481 delete[] fIntegralTerm ; 591 delete[] fDifPAIxSection ; << 482 delete[] fDifPAIxSection ; 592 delete[] fIntegralPAIxSection ; << 483 delete[] fIntegralPAIxSection ; 593 */ //////////////////////// 484 */ //////////////////////// 594 delete fMatSandiaMatrix; << 595 } << 596 << 597 G4double G4PAIxSection::GetLorentzFactor(G4int << 598 { << 599 return fLorentzFactor[j]; << 600 } << 601 << 602 ////////////////////////////////////////////// << 603 // << 604 // Constructor with beta*gamma square value ca << 605 << 606 void G4PAIxSection::Initialize( const G4Materi << 607 G4double maxEn << 608 G4double betaG << 609 G4SandiaTable* << 610 { << 611 if(fVerbose > 0) << 612 { << 613 G4cout<<G4endl; << 614 G4cout<<"G4PAIxSection::Initialize(...,G4S << 615 G4cout<<G4endl; << 616 } << 617 G4int i, j; << 618 << 619 fSandia = sandia; << 620 fIntervalNumber = sandia->GetMaxInterval(); << 621 fDensity = material->GetDensity(); << 622 fElectronDensity = material->GetElectronDens << 623 << 624 // fIntervalNumber--; << 625 << 626 if( fVerbose > 0 ) << 627 { << 628 G4cout<<"fDensity = "<<fDensity<<"\t"<<fEl << 629 } << 630 fEnergyInterval = G4DataVector(fIntervalNumb << 631 fA1 = G4DataVector(fIntervalNumb << 632 fA2 = G4DataVector(fIntervalNumb << 633 fA3 = G4DataVector(fIntervalNumb << 634 fA4 = G4DataVector(fIntervalNumb << 635 << 636 for( i = 1; i <= fIntervalNumber; i++ ) << 637 { << 638 if ( sandia->GetSandiaMatTablePAI(i-1,0) < << 639 { << 640 fIntervalNumber--; << 641 continue; << 642 } << 643 if( ( sandia->GetSandiaMatTablePAI(i-1,0) << 644 { << 645 fEnergyInterval[i] = maxEnergyTransfer; << 646 fIntervalNumber = i; << 647 break; << 648 } << 649 fEnergyInterval[i] = sandia->GetSandiaMatT << 650 fA1[i] = sandia->GetSandiaMatT << 651 fA2[i] = sandia->GetSandiaMatT << 652 fA3[i] = sandia->GetSandiaMatT << 653 fA4[i] = sandia->GetSandiaMatT << 654 << 655 if( fVerbose > 0 ) << 656 { << 657 G4cout<<i<<"\t"<<fEnergyInterval[i]/ke << 658 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4e << 659 } << 660 } << 661 if( fVerbose > 0 ) G4cout<<"last i = "<<i<<" << 662 << 663 if( fEnergyInterval[fIntervalNumber] != maxE << 664 { << 665 fIntervalNumber++; << 666 fEnergyInterval[fIntervalNumber] = maxEn << 667 } << 668 if( fVerbose > 0 ) << 669 { << 670 for( i = 1; i <= fIntervalNumber; i++ ) << 671 { << 672 G4cout<<i<<"\t"<<fEnergyInterval[i]/keV< << 673 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl; << 674 } << 675 } << 676 if( fVerbose > 0 ) G4cout<<"Now checking, << 677 << 678 for( i = 1; i < fIntervalNumber; i++ ) << 679 { << 680 if( fEnergyInterval[i+1]-fEnergyInterval[i << 681 1.5*fDelta*(fEnergyInterval[i+1]+fEne << 682 else << 683 { << 684 if( fVerbose > 0 ) G4cout<<i<<"\t"<<fEn << 685 << 686 for( j = i; j < fIntervalNumber; j++ ) << 687 { << 688 fEnergyInterval[j] = fEnergyInte << 689 fA1[j] = fA1[j+1]; << 690 fA2[j] = fA2[j+1]; << 691 fA3[j] = fA3[j+1]; << 692 fA4[j] = fA4[j+1]; << 693 } << 694 fIntervalNumber--; << 695 i--; << 696 } << 697 } << 698 if( fVerbose > 0 ) << 699 { << 700 for( i = 1; i <= fIntervalNumber; i++ ) << 701 { << 702 G4cout<<i<<"\t"<<fEnergyInterval[i]/keV< << 703 <<fA3[i]<<"\t"<<fA4[i]<<"\t"<<G4endl; << 704 } << 705 } << 706 // Preparation of fSplineEnergy array corres << 707 << 708 ComputeLowEnergyCof(material); << 709 << 710 G4double betaGammaSqRef = << 711 fLorentzFactor[fRefGammaNumber]*fLorentzFa << 712 << 713 NormShift(betaGammaSqRef); << 714 SplainPAI(betaGammaSqRef); << 715 << 716 // Preparation of integral PAI cross section << 717 << 718 for( i = 1; i <= fSplineNumber; i++ ) << 719 { << 720 fDifPAIxSection[i] = DifPAIxSection(i,bet << 721 << 722 << 723 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,be << 724 fdNdxMM[i] = PAIdNdxMM(i,betaGammaSq); << 725 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,bet << 726 fdNdxResonance[i] = PAIdNdxResonance(i,b << 727 } << 728 IntegralPAIxSection(); << 729 IntegralCerenkov(); << 730 IntegralMM(); << 731 IntegralPlasmon(); << 732 IntegralResonance(); << 733 << 734 for( i = 1; i <= fSplineNumber; i++ ) << 735 { << 736 if(fVerbose>0) G4cout<<i<<"; w = "<<fSplin << 737 } << 738 } << 739 << 740 << 741 ////////////////////////////////////////////// << 742 // << 743 // Compute low energy cof. It reduces PAI xsc << 744 // << 745 << 746 void G4PAIxSection::ComputeLowEnergyCof(const << 747 { << 748 G4int i, numberOfElements = (G4int)material- << 749 G4double sumZ = 0., sumCof = 0.; << 750 << 751 static const G4double p0 = 1.20923e+00; << 752 static const G4double p1 = 3.53256e-01; << 753 static const G4double p2 = -1.45052e-03; << 754 << 755 G4double* thisMaterialZ = new G4double[num << 756 G4double* thisMaterialCof = new G4double[num << 757 << 758 for( i = 0; i < numberOfElements; ++i ) << 759 { << 760 thisMaterialZ[i] = material->GetElement(i) << 761 sumZ += thisMaterialZ[i]; << 762 thisMaterialCof[i] = p0+p1*thisMaterialZ[i << 763 } << 764 for( i = 0; i < numberOfElements; ++i ) << 765 { << 766 sumCof += thisMaterialCof[i]*thisMaterialZ << 767 } << 768 fLowEnergyCof = sumCof; << 769 delete [] thisMaterialZ; << 770 delete [] thisMaterialCof; << 771 // G4cout<<"fLowEnergyCof = "<<fLowEnergyCof << 772 } << 773 << 774 ////////////////////////////////////////////// << 775 // << 776 // Compute low energy cof. It reduces PAI xsc << 777 // << 778 << 779 void G4PAIxSection::ComputeLowEnergyCof() << 780 { << 781 const G4MaterialTable* theMaterialTable = G4 << 782 G4int i, numberOfElements = (G4int)(*theMate << 783 G4double sumZ = 0., sumCof = 0.; << 784 << 785 const G4double p0 = 1.20923e+00; << 786 const G4double p1 = 3.53256e-01; << 787 const G4double p2 = -1.45052e-03; << 788 << 789 G4double* thisMaterialZ = new G4double[num << 790 G4double* thisMaterialCof = new G4double[num << 791 << 792 for( i = 0; i < numberOfElements; ++i ) << 793 { << 794 thisMaterialZ[i] = (*theMaterialTable)[fMa << 795 sumZ += thisMaterialZ[i]; << 796 thisMaterialCof[i] = p0+p1*thisMaterialZ[i << 797 } << 798 for( i = 0; i < numberOfElements; ++i ) << 799 { << 800 sumCof += thisMaterialCof[i]*thisMaterialZ << 801 } << 802 fLowEnergyCof = sumCof; << 803 // G4cout<<"fLowEnergyCof = "<<fLowEnergyCof << 804 delete [] thisMaterialZ; << 805 delete [] thisMaterialCof; << 806 } 485 } 807 486 808 ////////////////////////////////////////////// 487 ///////////////////////////////////////////////////////////////////////// 809 // 488 // 810 // General control function for class G4PAIxSe 489 // General control function for class G4PAIxSection 811 // 490 // 812 491 813 void G4PAIxSection::InitPAI() 492 void G4PAIxSection::InitPAI() 814 { 493 { 815 G4int i; << 494 G4int i ; 816 G4double betaGammaSq = fLorentzFactor[fRefG 495 G4double betaGammaSq = fLorentzFactor[fRefGammaNumber]* 817 fLorentzFactor[fRefG 496 fLorentzFactor[fRefGammaNumber] - 1; 818 497 819 // Preparation of integral PAI cross sectio 498 // Preparation of integral PAI cross section for reference gamma 820 499 821 NormShift(betaGammaSq); << 500 NormShift(betaGammaSq) ; 822 SplainPAI(betaGammaSq); << 501 SplainPAI(betaGammaSq) ; 823 502 824 IntegralPAIxSection(); << 503 IntegralPAIxSection() ; 825 IntegralCerenkov(); << 504 IntegralCerenkov() ; 826 IntegralMM(); << 505 IntegralPlasmon() ; 827 IntegralPlasmon(); << 828 IntegralResonance(); << 829 506 830 for(i = 0; i<= fSplineNumber; i++) << 507 for(i = 0 ; i<=fSplineNumber ; i++) 831 { 508 { 832 fPAItable[i][fRefGammaNumber] = fIntegra << 509 fPAItable[i][fRefGammaNumber] = fIntegralPAIxSection[i] ; 833 if(i != 0) 510 if(i != 0) 834 { 511 { 835 fPAItable[i][0] = fSplineEnergy[i]; << 512 fPAItable[i][0] = fSplineEnergy[i] ; 836 } 513 } 837 } 514 } 838 fPAItable[0][0] = fSplineNumber; << 515 fPAItable[0][0] = fSplineNumber ; 839 516 840 for(G4int j = 1; j < 112; j++) // for << 517 for(G4int j = 1 ; j < 112 ; j++) // for other gammas 841 { 518 { 842 if( j == fRefGammaNumber ) continue; << 519 if( j == fRefGammaNumber ) continue ; 843 520 844 betaGammaSq = fLorentzFactor[j]*fLorentz << 521 betaGammaSq = fLorentzFactor[j]*fLorentzFactor[j] - 1 ; 845 522 846 for(i = 1; i <= fSplineNumber; i++) << 523 for(i = 1 ; i <= fSplineNumber ; i++) 847 { 524 { 848 fDifPAIxSection[i] = DifPAIxSection(i 525 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq); 849 fdNdxCerenkov[i] = PAIdNdxCerenkov( 526 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq); 850 fdNdxMM[i] = PAIdNdxMM(i,betaGammaS << 851 fdNdxPlasmon[i] = PAIdNdxPlasmon(i 527 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq); 852 fdNdxResonance[i] = PAIdNdxResonance << 853 } 528 } 854 IntegralPAIxSection(); << 529 IntegralPAIxSection() ; 855 IntegralCerenkov(); << 530 IntegralCerenkov() ; 856 IntegralMM(); << 531 IntegralPlasmon() ; 857 IntegralPlasmon(); << 858 IntegralResonance(); << 859 532 860 for(i = 0; i <= fSplineNumber; i++) << 533 for(i = 0 ; i <= fSplineNumber ; i++) 861 { 534 { 862 fPAItable[i][j] = fIntegralPAIxSectio << 535 fPAItable[i][j] = fIntegralPAIxSection[i] ; 863 } 536 } 864 } 537 } 865 538 866 } 539 } 867 540 868 ////////////////////////////////////////////// 541 /////////////////////////////////////////////////////////////////////// 869 // 542 // 870 // Shifting from borders to intervals Creation 543 // Shifting from borders to intervals Creation of first energy points 871 // 544 // 872 545 873 void G4PAIxSection::NormShift(G4double betaGam 546 void G4PAIxSection::NormShift(G4double betaGammaSq) 874 { 547 { 875 G4int i, j; << 548 G4int i, j ; 876 << 877 if(fVerbose>0) G4cout<<" G4PAIxSection: << 878 549 879 << 550 for( i = 1 ; i <= fIntervalNumber-1 ; i++ ) 880 for( i = 1; i <= fIntervalNumber-1; i++ ) << 881 { 551 { 882 for( j = 1; j <= 2; j++ ) << 552 for( j = 1 ; j <= 2 ; j++ ) 883 { 553 { 884 fSplineNumber = (i-1)*2 + j; << 554 fSplineNumber = (i-1)*2 + j ; 885 555 886 if( j == 1 ) fSplineEnergy[fSplineNumber 556 if( j == 1 ) fSplineEnergy[fSplineNumber] = fEnergyInterval[i ]*(1+fDelta); 887 else fSplineEnergy[fSplineNumber 557 else fSplineEnergy[fSplineNumber] = fEnergyInterval[i+1]*(1-fDelta); 888 if(fVerbose>0) G4cout<<"cn = "<<fSplineN << 558 // G4cout<<"cn = "<<fSplineNumber<<"; "<<"energy = " >> 559 // <<fSplineEnergy[fSplineNumber]<<G4endl; 889 } 560 } 890 } 561 } 891 fIntegralTerm[1]=RutherfordIntegral(1,fEnerg 562 fIntegralTerm[1]=RutherfordIntegral(1,fEnergyInterval[1],fSplineEnergy[1]); 892 563 893 j = 1; << 564 j = 1 ; 894 565 895 for( i = 2; i <= fSplineNumber; i++ ) << 566 for(i=2;i<=fSplineNumber;i++) 896 { 567 { 897 if( fSplineEnergy[i]<fEnergyInterval[j+1] << 568 if(fSplineEnergy[i]<fEnergyInterval[j+1]) 898 { 569 { 899 fIntegralTerm[i] = fIntegralTerm[i-1] 570 fIntegralTerm[i] = fIntegralTerm[i-1] + 900 RutherfordIntegral << 571 RutherfordIntegral(j,fSplineEnergy[i-1], 901 << 572 fSplineEnergy[i] ) ; 902 } 573 } 903 else 574 else 904 { 575 { 905 G4double x = RutherfordIntegral(j,fSpli 576 G4double x = RutherfordIntegral(j,fSplineEnergy[i-1], 906 fEn << 577 fEnergyInterval[j+1] ) ; 907 j++; 578 j++; 908 fIntegralTerm[i] = fIntegralTerm[i-1] 579 fIntegralTerm[i] = fIntegralTerm[i-1] + x + 909 RutherfordIntegral << 580 RutherfordIntegral(j,fEnergyInterval[j], 910 << 581 fSplineEnergy[i] ) ; 911 } 582 } 912 if(fVerbose>0) G4cout<<i<<" Shift: w = "< << 583 // G4cout<<i<<"\t"<<fSplineEnergy[i]<<"\t"<<fIntegralTerm[i]<<"\n"<<G4endl; 913 } 584 } 914 fNormalizationCof = 2*pi*pi*hbarc*hbarc*fine << 585 fNormalizationCof = 2*pi*pi*hbarc*hbarc*fine_structure_const/electron_mass_c2 ; 915 fNormalizationCof *= fElectronDensity/fInteg << 586 fNormalizationCof *= fElectronDensity/fIntegralTerm[fSplineNumber] ; 916 587 917 // G4cout<<"fNormalizationCof = "<<fNormaliz << 588 // G4cout<<"fNormalizationCof = "<<fNormalizationCof<<G4endl ; 918 589 919 // Calculation of PAI differrential << 590 // Calculation of PAI differrential cross-section (1/(keV*cm)) 920 // in the energy points near borders << 591 // in the energy points near borders of energy intervals 921 592 922 for(G4int k = 1; k <= fIntervalNumber-1; k+ << 593 for(G4int k=1;k<=fIntervalNumber-1;k++) 923 { 594 { 924 for( j = 1; j <= 2; j++ ) << 595 for(j=1;j<=2;j++) 925 { 596 { 926 i = (k-1)*2 + j; << 597 i = (k-1)*2 + j ; 927 fImPartDielectricConst[i] = fNormaliz 598 fImPartDielectricConst[i] = fNormalizationCof* 928 ImPartDie << 599 ImPartDielectricConst(k,fSplineEnergy[i]); 929 fRePartDielectricConst[i] = fNormaliz 600 fRePartDielectricConst[i] = fNormalizationCof* 930 RePartDie << 601 RePartDielectricConst(fSplineEnergy[i]); 931 fIntegralTerm[i] *= fNormalizationCof 602 fIntegralTerm[i] *= fNormalizationCof; 932 603 933 fDifPAIxSection[i] = DifPAIxSection(i 604 fDifPAIxSection[i] = DifPAIxSection(i,betaGammaSq); 934 fdNdxCerenkov[i] = PAIdNdxCerenkov( 605 fdNdxCerenkov[i] = PAIdNdxCerenkov(i,betaGammaSq); 935 fdNdxMM[i] = PAIdNdxMM(i,betaGammaS << 936 fdNdxPlasmon[i] = PAIdNdxPlasmon(i 606 fdNdxPlasmon[i] = PAIdNdxPlasmon(i,betaGammaSq); 937 fdNdxResonance[i] = PAIdNdxResonan << 938 if(fVerbose>0) G4cout<<i<<" Shift: w = "< << 939 } 607 } 940 } 608 } 941 609 942 } // end of NormShift 610 } // end of NormShift 943 611 944 ////////////////////////////////////////////// 612 ///////////////////////////////////////////////////////////////////////// 945 // 613 // 946 // Creation of new energy points as geometrica 614 // Creation of new energy points as geometrical mean of existing 947 // one, calculation PAI_cs for them, while the 615 // one, calculation PAI_cs for them, while the error of logarithmic 948 // linear approximation would be smaller than 616 // linear approximation would be smaller than 'fError' 949 617 950 void G4PAIxSection::SplainPAI(G4double betaGam << 618 void >> 619 G4PAIxSection::SplainPAI(G4double betaGammaSq) 951 { 620 { 952 G4int j, k = 1, i = 1; << 621 G4int k = 1 ; 953 << 622 G4int i = 1 ; 954 if(fVerbose>0) G4cout<<" G << 955 623 956 while ( (i < fSplineNumber) && (fSplineNumbe << 624 while ( (i < fSplineNumber) && (fSplineNumber < fMaxSplineSize-1) ) 957 { << 625 { 958 // if( std::abs(fSplineEnergy[i+1]-fEnerg << 626 if(fSplineEnergy[i+1] > fEnergyInterval[k+1]) 959 if( fSplineEnergy[i+1] > fEnergyInterval[ << 627 { 960 { << 628 k++ ; // Here next energy point is in next energy interval 961 k++; // Here next energy point is << 629 i++; 962 i++; << 963 if(fVerbose>0) G4cout<<" << 964 continue; 630 continue; 965 } << 631 } 966 if(fVerbose>0) G4cout<<" out if: i << 632 // Shifting of arrayes for inserting the geometrical 967 << 633 // average of 'i' and 'i+1' energy points to 'i+1' place 968 // Shifting of arrayes << 634 fSplineNumber++; 969 // average of 'i' and ' << 970 fSplineNumber++; << 971 635 972 for( j = fSplineNumber; j >= i+2; j-- ) << 636 for(G4int j = fSplineNumber; j >= i+2 ; j-- ) 973 { << 637 { 974 fSplineEnergy[j] = fSplineEn 638 fSplineEnergy[j] = fSplineEnergy[j-1]; 975 fImPartDielectricConst[j] = fImPartDi 639 fImPartDielectricConst[j] = fImPartDielectricConst[j-1]; 976 fRePartDielectricConst[j] = fRePartDi << 640 fRePartDielectricConst[j] = fRePartDielectricConst[j-1]; 977 fIntegralTerm[j] = fIntegral << 641 fIntegralTerm[j] = fIntegralTerm[j-1]; 978 642 979 fDifPAIxSection[j] = fDifPAIxSection[ << 643 fDifPAIxSection[j] = fDifPAIxSection[j-1]; 980 fdNdxCerenkov[j] = fdNdxCerenkov[j- 644 fdNdxCerenkov[j] = fdNdxCerenkov[j-1]; 981 fdNdxMM[j] = fdNdxMM[j-1]; << 982 fdNdxPlasmon[j] = fdNdxPlasmon[j-1 645 fdNdxPlasmon[j] = fdNdxPlasmon[j-1]; 983 fdNdxResonance[j] = fdNdxResonance[j << 646 } 984 } << 985 G4double x1 = fSplineEnergy[i]; 647 G4double x1 = fSplineEnergy[i]; 986 G4double x2 = fSplineEnergy[i+1]; 648 G4double x2 = fSplineEnergy[i+1]; 987 G4double yy1 = fDifPAIxSection[i]; 649 G4double yy1 = fDifPAIxSection[i]; 988 G4double y2 = fDifPAIxSection[i+1]; 650 G4double y2 = fDifPAIxSection[i+1]; 989 651 990 if(fVerbose>0) G4cout<<"Spline: x1 = "<< << 991 << 992 << 993 G4double en1 = sqrt(x1*x2); 652 G4double en1 = sqrt(x1*x2); 994 // G4double en1 = 0.5*(x1 + x2); << 995 << 996 << 997 fSplineEnergy[i+1] = en1; 653 fSplineEnergy[i+1] = en1; 998 654 999 // Calculation of logarithmic << 655 // Calculation of logarithmic linear approximation 1000 // in this (enr) energy poin << 656 // in this (enr) energy point, which number is 'i+1' now 1001 657 1002 G4double a = log10(y2/yy1)/log10(x2/x1) 658 G4double a = log10(y2/yy1)/log10(x2/x1); 1003 G4double b = log10(yy1) - a*log10(x1); 659 G4double b = log10(yy1) - a*log10(x1); 1004 G4double y = a*log10(en1) + b; << 660 G4double y = a*log10(en1) + b ; 1005 << 1006 y = pow(10.,y); 661 y = pow(10.,y); 1007 662 1008 // Calculation of the PAI di << 663 // Calculation of the PAI dif. cross-section at this point 1009 664 1010 fImPartDielectricConst[i+1] = fNormaliz 665 fImPartDielectricConst[i+1] = fNormalizationCof* 1011 ImPartDie << 666 ImPartDielectricConst(k,fSplineEnergy[i+1]); 1012 fRePartDielectricConst[i+1] = fNormaliz 667 fRePartDielectricConst[i+1] = fNormalizationCof* 1013 RePartDie << 668 RePartDielectricConst(fSplineEnergy[i+1]); 1014 fIntegralTerm[i+1] = fIntegralTerm[i] + 669 fIntegralTerm[i+1] = fIntegralTerm[i] + fNormalizationCof* 1015 RutherfordIntegral << 670 RutherfordIntegral(k,fSplineEnergy[i], 1016 671 fSplineEnergy[i+1]); 1017 672 1018 fDifPAIxSection[i+1] = DifPAIxSection(i 673 fDifPAIxSection[i+1] = DifPAIxSection(i+1,betaGammaSq); 1019 fdNdxCerenkov[i+1] = PAIdNdxCerenkov( 674 fdNdxCerenkov[i+1] = PAIdNdxCerenkov(i+1,betaGammaSq); 1020 fdNdxMM[i+1] = PAIdNdxMM(i+1,be << 1021 fdNdxPlasmon[i+1] = PAIdNdxPlasmon(i 675 fdNdxPlasmon[i+1] = PAIdNdxPlasmon(i+1,betaGammaSq); 1022 fdNdxResonance[i+1] = PAIdNdxResonance << 1023 676 1024 // Condition for next divis << 677 // Condition for next division of this segment or to pass 1025 << 678 // to higher energies 1026 if(fVerbose>0) G4cout<<"Spline, a = "<<a< << 1027 << 1028 // to higher energies << 1029 679 1030 G4double x = 2*(fDifPAIxSection[i+1] - 680 G4double x = 2*(fDifPAIxSection[i+1] - y)/(fDifPAIxSection[i+1] + y); 1031 681 1032 G4double delta = 2.*(fSplineEnergy[i+1] << 1033 << 1034 if( x < 0 ) 682 if( x < 0 ) 1035 { 683 { 1036 x = -x; << 684 x = -x ; 1037 } 685 } 1038 if( x > fError && fSplineNumber < fMaxS << 686 if( x > fError && fSplineNumber < fMaxSplineSize-1 ) 1039 { 687 { 1040 continue; // next division << 688 continue; // next division 1041 } 689 } 1042 i += 2; // pass to next segment 690 i += 2; // pass to next segment 1043 691 1044 // Loop checking, 03-Aug-2015, Vladimir << 692 } // close 'while' 1045 } // close 'while' << 1046 693 1047 } // end of SplainPAI 694 } // end of SplainPAI 1048 695 1049 696 1050 ///////////////////////////////////////////// 697 //////////////////////////////////////////////////////////////////// 1051 // 698 // 1052 // Integration over electrons that could be c 699 // Integration over electrons that could be considered 1053 // quasi-free at energy transfer of interest 700 // quasi-free at energy transfer of interest 1054 701 1055 G4double G4PAIxSection::RutherfordIntegral( G 702 G4double G4PAIxSection::RutherfordIntegral( G4int k, 1056 G << 703 G4double x1, 1057 << 704 G4double x2 ) 1058 { 705 { 1059 G4double c1, c2, c3; << 706 G4double c1, c2, c3 ; 1060 // G4cout<<"RI: x1 = "<<x1<<"; "<<"x2 = "< 707 // G4cout<<"RI: x1 = "<<x1<<"; "<<"x2 = "<<x2<<G4endl; 1061 c1 = (x2 - x1)/x1/x2; << 708 c1 = (x2 - x1)/x1/x2 ; 1062 c2 = (x2 - x1)*(x2 + x1)/x1/x1/x2/x2; << 709 c2 = (x2 - x1)*(x2 + x1)/x1/x1/x2/x2 ; 1063 c3 = (x2 - x1)*(x1*x1 + x1*x2 + x2*x2)/x1/ << 710 c3 = (x2 - x1)*(x1*x1 + x1*x2 + x2*x2)/x1/x1/x1/x2/x2/x2 ; 1064 // G4cout<<" RI: c1 = "<<c1<<"; "<<"c2 = " 711 // G4cout<<" RI: c1 = "<<c1<<"; "<<"c2 = "<<c2<<"; "<<"c3 = "<<c3<<G4endl; 1065 712 1066 return fA1[k]*log(x2/x1) + fA2[k]*c1 + fA << 713 return fA1[k]*log(x2/x1) + fA2[k]*c1 + fA3[k]*c2/2 + fA4[k]*c3/3 ; 1067 714 1068 } // end of RutherfordIntegral 715 } // end of RutherfordIntegral 1069 716 1070 717 1071 ///////////////////////////////////////////// 718 ///////////////////////////////////////////////////////////////// 1072 // 719 // 1073 // Imaginary part of dielectric constant 720 // Imaginary part of dielectric constant 1074 // (G4int k - interval number, G4double en1 - 721 // (G4int k - interval number, G4double en1 - energy point) 1075 722 1076 G4double G4PAIxSection::ImPartDielectricConst 723 G4double G4PAIxSection::ImPartDielectricConst( G4int k , 1077 << 724 G4double energy1 ) 1078 { 725 { 1079 G4double energy2,energy3,energy4,result; 726 G4double energy2,energy3,energy4,result; 1080 727 1081 energy2 = energy1*energy1; 728 energy2 = energy1*energy1; 1082 energy3 = energy2*energy1; 729 energy3 = energy2*energy1; 1083 energy4 = energy3*energy1; 730 energy4 = energy3*energy1; 1084 731 1085 result = fA1[k]/energy1+fA2[k]/energy2+fA3 << 732 result = fA1[k]/energy1+fA2[k]/energy2+fA3[k]/energy3+fA4[k]/energy4 ; 1086 result *=hbarc/energy1; << 733 result *=hbarc/energy1 ; 1087 734 1088 return result; << 735 return result ; 1089 736 1090 } // end of ImPartDielectricConst 737 } // end of ImPartDielectricConst 1091 738 1092 ///////////////////////////////////////////// << 1093 // << 1094 // Returns lambda of photon with energy1 in c << 1095 << 1096 G4double G4PAIxSection::GetPhotonRange( G4dou << 1097 { << 1098 G4int i; << 1099 G4double energy2, energy3, energy4, result, << 1100 << 1101 energy2 = energy1*energy1; << 1102 energy3 = energy2*energy1; << 1103 energy4 = energy3*energy1; << 1104 << 1105 for( i = 1; i <= fIntervalNumber; i++ ) << 1106 { << 1107 if( energy1 < fEnergyInterval[i]) break; << 1108 } << 1109 i--; << 1110 if(i == 0) i = 1; << 1111 << 1112 result = fA1[i]/energy1+fA2[i]/energy2+fA3[ << 1113 << 1114 if( result > DBL_MIN ) lambda = 1./result; << 1115 else lambda = DBL_MAX; << 1116 << 1117 return lambda; << 1118 } << 1119 << 1120 ///////////////////////////////////////////// << 1121 // << 1122 // Return lambda of electron with energy1 in << 1123 // parametrisation from NIM A554(2005)474-493 << 1124 << 1125 G4double G4PAIxSection::GetElectronRange( G4d << 1126 { << 1127 G4double range; << 1128 /* << 1129 const G4MaterialTable* theMaterialTable = G << 1130 << 1131 G4double Z = (*theMaterialTable)[fMaterialI << 1132 G4double A = (*theMaterialTable)[fMaterialI << 1133 << 1134 energy /= keV; // energy in keV in parametr << 1135 << 1136 if (energy < 10.) << 1137 { << 1138 range = 3.872e-3*A/Z; << 1139 range *= pow(energy,1.492); << 1140 } << 1141 else << 1142 { << 1143 range = 6.97e-3*pow(energy,1.6); << 1144 } << 1145 */ << 1146 // Blum&Rolandi Particle Detection with Dri << 1147 << 1148 G4double cofA = 5.37e-4*g/cm2/keV; << 1149 G4double cofB = 0.9815; << 1150 G4double cofC = 3.123e-3/keV; << 1151 // energy /= keV; << 1152 << 1153 range = cofA*energy*( 1 - cofB/(1 + cofC*en << 1154 << 1155 // range *= g/cm2; << 1156 range /= fDensity; << 1157 << 1158 return range; << 1159 } << 1160 739 1161 ///////////////////////////////////////////// 740 ////////////////////////////////////////////////////////////////////////////// 1162 // 741 // 1163 // Real part of dielectric constant minus uni 742 // Real part of dielectric constant minus unit: epsilon_1 - 1 1164 // (G4double enb - energy point) 743 // (G4double enb - energy point) 1165 // 744 // 1166 745 1167 G4double G4PAIxSection::RePartDielectricConst 746 G4double G4PAIxSection::RePartDielectricConst(G4double enb) 1168 { 747 { 1169 G4double x0, x02, x03, x04, x05, x1, x2, x 748 G4double x0, x02, x03, x04, x05, x1, x2, xx1 ,xx2 , xx12, 1170 c1, c2, c3, cof1, cof2, xln1, xln << 749 c1, c2, c3, cof1, cof2, xln1, xln2, xln3, result ; 1171 750 1172 x0 = enb; << 751 x0 = enb ; 1173 result = 0; << 752 result = 0 ; 1174 753 1175 for(G4int i=1;i<=fIntervalNumber-1;i++) 754 for(G4int i=1;i<=fIntervalNumber-1;i++) 1176 { 755 { 1177 x1 = fEnergyInterval[i]; << 756 x1 = fEnergyInterval[i] ; 1178 x2 = fEnergyInterval[i+1]; << 757 x2 = fEnergyInterval[i+1] ; 1179 xx1 = x1 - x0; << 758 xx1 = x1 - x0 ; 1180 xx2 = x2 - x0; << 759 xx2 = x2 - x0 ; 1181 xx12 = xx2/xx1; << 760 xx12 = xx2/xx1 ; 1182 761 1183 if(xx12<0) 762 if(xx12<0) 1184 { 763 { 1185 xx12 = -xx12; << 764 xx12 = -xx12; 1186 } 765 } 1187 xln1 = log(x2/x1); << 766 xln1 = log(x2/x1) ; 1188 xln2 = log(xx12); << 767 xln2 = log(xx12) ; 1189 xln3 = log((x2 + x0)/(x1 + x0)); << 768 xln3 = log((x2 + x0)/(x1 + x0)) ; 1190 x02 = x0*x0; << 769 x02 = x0*x0 ; 1191 x03 = x02*x0; << 770 x03 = x02*x0 ; 1192 x04 = x03*x0; << 771 x04 = x03*x0 ; 1193 x05 = x04*x0; 772 x05 = x04*x0; 1194 c1 = (x2 - x1)/x1/x2; << 773 c1 = (x2 - x1)/x1/x2 ; 1195 c2 = (x2 - x1)*(x2 +x1)/x1/x1/x2/x2; << 774 c2 = (x2 - x1)*(x2 +x1)/x1/x1/x2/x2 ; 1196 c3 = (x2 -x1)*(x1*x1 + x1*x2 + x2*x2)/ << 775 c3 = (x2 -x1)*(x1*x1 + x1*x2 + x2*x2)/x1/x1/x1/x2/x2/x2 ; 1197 << 776 1198 result -= (fA1[i]/x02 + fA3[i]/x04)*xln << 777 result -= (fA1[i]/x02 + fA3[i]/x04)*xln1 ; 1199 result -= (fA2[i]/x02 + fA4[i]/x04)*c1; << 778 result -= (fA2[i]/x02 + fA4[i]/x04)*c1 ; 1200 result -= fA3[i]*c2/2/x02; << 779 result -= fA3[i]*c2/2/x02 ; 1201 result -= fA4[i]*c3/3/x02; << 780 result -= fA4[i]*c3/3/x02 ; 1202 781 1203 cof1 = fA1[i]/x02 + fA3[i]/x04; << 782 cof1 = fA1[i]/x02 + fA3[i]/x04 ; 1204 cof2 = fA2[i]/x03 + fA4[i]/x05; << 783 cof2 = fA2[i]/x03 + fA4[i]/x05 ; 1205 784 1206 result += 0.5*(cof1 +cof2)*xln2; << 785 result += 0.5*(cof1 +cof2)*xln2 ; 1207 result += 0.5*(cof1 - cof2)*xln3; << 786 result += 0.5*(cof1 - cof2)*xln3 ; 1208 } 787 } 1209 result *= 2*hbarc/pi; << 788 result *= 2*hbarc/pi ; 1210 789 1211 return result; << 790 return result ; 1212 791 1213 } // end of RePartDielectricConst 792 } // end of RePartDielectricConst 1214 793 1215 ///////////////////////////////////////////// 794 ////////////////////////////////////////////////////////////////////// 1216 // 795 // 1217 // PAI differential cross-section in terms of 796 // PAI differential cross-section in terms of 1218 // simplified Allison's equation 797 // simplified Allison's equation 1219 // 798 // 1220 799 1221 G4double G4PAIxSection::DifPAIxSection( G4int << 800 G4double G4PAIxSection::DifPAIxSection( G4int i , >> 801 G4double betaGammaSq ) 1222 { 802 { 1223 G4double cof,x1,x2,x3,x4,x5,x6,x7,x8,resul << 803 G4double be2,cof,x1,x2,x3,x4,x5,x6,x7,x8,result ; 1224 << 804 //G4double beta, be4 ; 1225 G4double betaBohr = fine_structure_const; << 805 G4double be4 ; 1226 G4double be2 = betaGammaSq/(1 + betaGamma << 806 G4double betaBohr2 = fine_structure_const*fine_structure_const ; 1227 G4double beta = std::sqrt(be2); << 807 G4double betaBohr4 = betaBohr2*betaBohr2*4.0 ; >> 808 be2 = betaGammaSq/(1 + betaGammaSq) ; >> 809 be4 = be2*be2 ; >> 810 // beta = sqrt(be2) ; >> 811 cof = 1 ; >> 812 x1 = log(2*electron_mass_c2/fSplineEnergy[i]) ; 1228 813 1229 cof = 1.; << 814 if( betaGammaSq < 0.01 ) x2 = log(be2) ; 1230 x1 = std::log(2*electron_mass_c2/fSplineE << 1231 << 1232 if( betaGammaSq < 0.01 ) x2 = std::log(be2 << 1233 else 815 else 1234 { 816 { 1235 x2 = -log( (1/betaGammaSq - fRePartDiele 817 x2 = -log( (1/betaGammaSq - fRePartDielectricConst[i])* 1236 (1/betaGammaSq - fRePartDiele << 818 (1/betaGammaSq - fRePartDielectricConst[i]) + 1237 fImPartDielectricConst[i]*fIm << 819 fImPartDielectricConst[i]*fImPartDielectricConst[i] )/2 ; 1238 } 820 } 1239 if( fImPartDielectricConst[i] == 0.0 ||bet 821 if( fImPartDielectricConst[i] == 0.0 ||betaGammaSq < 0.01 ) 1240 { 822 { 1241 x6 = 0.; << 823 x6=0 ; 1242 } 824 } 1243 else 825 else 1244 { 826 { 1245 x3 = -fRePartDielectricConst[i] + 1/beta << 827 x3 = -fRePartDielectricConst[i] + 1/betaGammaSq ; 1246 x5 = -1 - fRePartDielectricConst[i] + 828 x5 = -1 - fRePartDielectricConst[i] + 1247 be2*((1 +fRePartDielectricConst[i]) 829 be2*((1 +fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) + 1248 fImPartDielectricConst[i]*fImPartDi << 830 fImPartDielectricConst[i]*fImPartDielectricConst[i]) ; 1249 831 1250 x7 = atan2(fImPartDielectricConst[i],x3) << 832 x7 = atan2(fImPartDielectricConst[i],x3) ; 1251 x6 = x5 * x7; << 833 x6 = x5 * x7 ; 1252 } 834 } >> 835 // if(fImPartDielectricConst[i] == 0) x6 = 0 ; 1253 836 1254 x4 = ((x1 + x2)*fImPartDielectricConst[i] << 837 x4 = ((x1 + x2)*fImPartDielectricConst[i] + x6)/hbarc ; 1255 << 838 // if( x4 < 0.0 ) x4 = 0.0 ; 1256 x8 = (1 + fRePartDielectricConst[i])*(1 + 839 x8 = (1 + fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) + 1257 fImPartDielectricConst[i]*fImPartDiel << 840 fImPartDielectricConst[i]*fImPartDielectricConst[i] ; 1258 << 1259 result = (x4 + cof*fIntegralTerm[i]/fSplin << 1260 << 1261 if( result < 1.0e-8 ) result = 1.0e-8; << 1262 << 1263 result *= fine_structure_const/be2/pi; << 1264 << 1265 // low energy correction << 1266 841 1267 G4double lowCof = fLowEnergyCof; // 6.0 ; << 842 result = (x4 + cof*fIntegralTerm[i]/fSplineEnergy[i]/fSplineEnergy[i]) ; 1268 << 843 if(result < 1.0e-8) result = 1.0e-8 ; 1269 result *= (1 - std::exp(-beta/betaBohr/low << 844 result *= fine_structure_const/be2/pi ; 1270 if(x8 >= 0.0) << 845 // result *= (1-exp(-beta/betaBohr))*(1-exp(-beta/betaBohr)) ; >> 846 // result *= (1-exp(-be2/betaBohr2)) ; >> 847 result *= (1-exp(-be4/betaBohr4)) ; >> 848 if(fDensity >= 0.1) 1271 { 849 { 1272 result /= x8; << 850 result /= x8 ; 1273 } 851 } 1274 return result; << 852 return result ; 1275 853 1276 } // end of DifPAIxSection 854 } // end of DifPAIxSection 1277 855 1278 ///////////////////////////////////////////// 856 ////////////////////////////////////////////////////////////////////////// 1279 // 857 // 1280 // Calculation od dN/dx of collisions with cr 858 // Calculation od dN/dx of collisions with creation of Cerenkov pseudo-photons 1281 859 1282 G4double G4PAIxSection::PAIdNdxCerenkov( G4in 860 G4double G4PAIxSection::PAIdNdxCerenkov( G4int i , 1283 G4do 861 G4double betaGammaSq ) 1284 { 862 { 1285 G4double logarithm, x3, x5, argument, modu << 863 G4double cof, logarithm, x3, x5, argument, modul2, dNdxC ; 1286 G4double be2, betaBohr2, cofBetaBohr; << 864 G4double be2, be4, betaBohr2,betaBohr4,cofBetaBohr ; 1287 865 1288 cofBetaBohr = 4.0; << 866 cof = 1.0 ; 1289 betaBohr2 = fine_structure_const*fine_stru << 867 cofBetaBohr = 4.0 ; 1290 G4double betaBohr4 = betaBohr2*betaBohr2*c << 868 betaBohr2 = fine_structure_const*fine_structure_const ; >> 869 betaBohr4 = betaBohr2*betaBohr2*cofBetaBohr ; 1291 870 1292 be2 = betaGammaSq/(1 + betaGammaSq); << 871 be2 = betaGammaSq/(1 + betaGammaSq) ; 1293 G4double be4 = be2*be2; << 872 be4 = be2*be2 ; 1294 873 1295 if( betaGammaSq < 0.01 ) logarithm = std:: << 874 if( betaGammaSq < 0.01 ) logarithm = log(1.0+betaGammaSq) ; // 0.0 ; 1296 else 875 else 1297 { 876 { 1298 logarithm = -log( (1/betaGammaSq - fReP 877 logarithm = -log( (1/betaGammaSq - fRePartDielectricConst[i])* 1299 (1/betaGammaSq - fReP << 878 (1/betaGammaSq - fRePartDielectricConst[i]) + 1300 fImPartDielectricCons << 879 fImPartDielectricConst[i]*fImPartDielectricConst[i] )*0.5 ; 1301 logarithm += log(1+1.0/betaGammaSq); << 880 logarithm += log(1+1.0/betaGammaSq) ; 1302 } 881 } 1303 882 1304 if( fImPartDielectricConst[i] == 0.0 || be 883 if( fImPartDielectricConst[i] == 0.0 || betaGammaSq < 0.01 ) 1305 { 884 { 1306 argument = 0.0; << 885 argument = 0.0 ; 1307 } 886 } 1308 else 887 else 1309 { 888 { 1310 x3 = -fRePartDielectricConst[i] + 1.0/be << 889 x3 = -fRePartDielectricConst[i] + 1.0/betaGammaSq ; 1311 x5 = -1.0 - fRePartDielectricConst[i] + 890 x5 = -1.0 - fRePartDielectricConst[i] + 1312 be2*((1.0 +fRePartDielectricConst[i 891 be2*((1.0 +fRePartDielectricConst[i])*(1.0 + fRePartDielectricConst[i]) + 1313 fImPartDielectricConst[i]*fImPartDi << 892 fImPartDielectricConst[i]*fImPartDielectricConst[i]) ; 1314 if( x3 == 0.0 ) argument = 0.5*pi; 893 if( x3 == 0.0 ) argument = 0.5*pi; 1315 else argument = std::atan2(fI << 894 else argument = atan2(fImPartDielectricConst[i],x3) ; 1316 argument *= x5 ; << 895 argument *= x5 ; 1317 } 896 } 1318 dNdxC = ( logarithm*fImPartDielectricConst << 897 dNdxC = ( logarithm*fImPartDielectricConst[i] + argument )/hbarc ; 1319 898 1320 if(dNdxC < 1.0e-8) dNdxC = 1.0e-8; << 899 if(dNdxC < 1.0e-8) dNdxC = 1.0e-8 ; 1321 900 1322 dNdxC *= fine_structure_const/be2/pi; << 901 dNdxC *= fine_structure_const/be2/pi ; 1323 902 1324 dNdxC *= (1-std::exp(-be4/betaBohr4)); << 903 dNdxC *= (1-exp(-be4/betaBohr4)) ; 1325 904 1326 modul2 = (1.0 + fRePartDielectricConst[i]) << 905 if(fDensity >= 0.1) 1327 fImPartDielectricConst[i]*fImPartDielect << 1328 if(modul2 >= 0.0) << 1329 { 906 { 1330 dNdxC /= modul2; << 907 modul2 = (1.0 + fRePartDielectricConst[i])*(1.0 + fRePartDielectricConst[i]) + >> 908 fImPartDielectricConst[i]*fImPartDielectricConst[i] ; >> 909 dNdxC /= modul2 ; 1331 } 910 } 1332 return dNdxC; << 911 return dNdxC ; 1333 912 1334 } // end of PAIdNdxCerenkov 913 } // end of PAIdNdxCerenkov 1335 914 1336 ///////////////////////////////////////////// 915 ////////////////////////////////////////////////////////////////////////// 1337 // 916 // 1338 // Calculation od dN/dx of collisions of MM w << 1339 << 1340 G4double G4PAIxSection::PAIdNdxMM( G4int i << 1341 G4do << 1342 { << 1343 G4double logarithm, x3, x5, argument, dNdx << 1344 G4double be2, be4, betaBohr2,betaBohr4,cof << 1345 << 1346 cofBetaBohr = 4.0; << 1347 betaBohr2 = fine_structure_const*fine_st << 1348 betaBohr4 = betaBohr2*betaBohr2*cofBetaB << 1349 << 1350 be2 = betaGammaSq/(1 + betaGammaSq); << 1351 be4 = be2*be2; << 1352 << 1353 if( betaGammaSq < 0.01 ) logarithm = log(1 << 1354 else << 1355 { << 1356 logarithm = -log( (1/betaGammaSq - fReP << 1357 (1/betaGammaSq - fReP << 1358 fImPartDielectricCons << 1359 logarithm += log(1+1.0/betaGammaSq); << 1360 } << 1361 << 1362 if( fImPartDielectricConst[i] == 0.0 || be << 1363 { << 1364 argument = 0.0; << 1365 } << 1366 else << 1367 { << 1368 x3 = -fRePartDielectricConst[i] + 1.0/be << 1369 x5 = be2*( 1.0 + fRePartDielectricConst[ << 1370 if( x3 == 0.0 ) argument = 0.5*pi; << 1371 else argument = atan2(fImPart << 1372 argument *= x5 ; << 1373 } << 1374 dNdxC = ( logarithm*fImPartDielectricConst << 1375 << 1376 if(dNdxC < 1.0e-8) dNdxC = 1.0e-8; << 1377 << 1378 dNdxC *= fine_structure_const/be2/pi; << 1379 << 1380 dNdxC *= (1-std::exp(-be4/betaBohr4)); << 1381 return dNdxC; << 1382 << 1383 } // end of PAIdNdxMM << 1384 << 1385 ///////////////////////////////////////////// << 1386 // << 1387 // Calculation od dN/dx of collisions with cr 917 // Calculation od dN/dx of collisions with creation of longitudinal EM 1388 // excitations (plasmons, delta-electrons) 918 // excitations (plasmons, delta-electrons) 1389 919 1390 G4double G4PAIxSection::PAIdNdxPlasmon( G4int 920 G4double G4PAIxSection::PAIdNdxPlasmon( G4int i , 1391 G4dou 921 G4double betaGammaSq ) 1392 { 922 { 1393 G4double resonance, modul2, dNdxP, cof = 1 << 923 G4double cof, resonance, modul2, dNdxP ; 1394 G4double be2, betaBohr; << 924 G4double be2, be4, betaBohr2, betaBohr4, cofBetaBohr ; 1395 << 1396 betaBohr = fine_structure_const; << 1397 be2 = betaGammaSq/(1 + betaGammaSq); << 1398 925 1399 G4double beta = std::sqrt(be2); << 926 cof = 1 ; >> 927 cofBetaBohr = 4.0 ; >> 928 betaBohr2 = fine_structure_const*fine_structure_const ; >> 929 betaBohr4 = betaBohr2*betaBohr2*cofBetaBohr ; >> 930 >> 931 be2 = betaGammaSq/(1 + betaGammaSq) ; >> 932 be4 = be2*be2 ; 1400 933 1401 resonance = std::log(2*electron_mass_c2*be << 934 resonance = log(2*electron_mass_c2*be2/fSplineEnergy[i]) ; 1402 resonance *= fImPartDielectricConst[i]/hba << 935 resonance *= fImPartDielectricConst[i]/hbarc ; 1403 936 1404 dNdxP = ( resonance + cof*fIntegralTerm[i] << 1405 937 1406 if( dNdxP < 1.0e-8 ) dNdxP = 1.0e-8; << 938 dNdxP = ( resonance + cof*fIntegralTerm[i]/fSplineEnergy[i]/fSplineEnergy[i] ) ; 1407 939 1408 dNdxP *= fine_structure_const/be2/pi; << 940 if( dNdxP < 1.0e-8 ) dNdxP = 1.0e-8 ; 1409 941 1410 dNdxP *= (1 - std::exp(-beta/betaBohr/fLo << 942 dNdxP *= fine_structure_const/be2/pi ; >> 943 dNdxP *= (1-exp(-be4/betaBohr4)) ; 1411 944 1412 modul2 = (1 + fRePartDielectricConst[i])*( << 945 if( fDensity >= 0.1 ) 1413 fImPartDielectricConst[i]*fImPartDielect << 1414 if( modul2 >= 0.0 ) << 1415 { 946 { 1416 dNdxP /= modul2; << 947 modul2 = (1 + fRePartDielectricConst[i])*(1 + fRePartDielectricConst[i]) + >> 948 fImPartDielectricConst[i]*fImPartDielectricConst[i] ; >> 949 dNdxP /= modul2 ; 1417 } 950 } 1418 return dNdxP; << 951 return dNdxP ; 1419 952 1420 } // end of PAIdNdxPlasmon 953 } // end of PAIdNdxPlasmon 1421 954 1422 ///////////////////////////////////////////// << 1423 // << 1424 // Calculation od dN/dx of collisions with cr << 1425 // resonance excitations (plasmons, delta-ele << 1426 << 1427 G4double G4PAIxSection::PAIdNdxResonance( G4i << 1428 G4dou << 1429 { << 1430 G4double resonance, modul2, dNdxP; << 1431 G4double be2, be4, betaBohr2, betaBohr4, c << 1432 << 1433 cofBetaBohr = 4.0; << 1434 betaBohr2 = fine_structure_const*fine_st << 1435 betaBohr4 = betaBohr2*betaBohr2*cofBetaB << 1436 << 1437 be2 = betaGammaSq/(1 + betaGammaSq); << 1438 be4 = be2*be2; << 1439 << 1440 resonance = log(2*electron_mass_c2*be2/fSp << 1441 resonance *= fImPartDielectricConst[i]/hba << 1442 << 1443 dNdxP = resonance; << 1444 << 1445 if( dNdxP < 1.0e-8 ) dNdxP = 1.0e-8; << 1446 << 1447 dNdxP *= fine_structure_const/be2/pi; << 1448 dNdxP *= (1 - std::exp(-be4/betaBohr4)); << 1449 << 1450 modul2 = (1 + fRePartDielectricConst[i])*( << 1451 fImPartDielectricConst[i]*fImPartDielect << 1452 if( modul2 >= 0.0 ) << 1453 { << 1454 dNdxP /= modul2; << 1455 } << 1456 return dNdxP; << 1457 << 1458 } // end of PAIdNdxResonance << 1459 << 1460 ///////////////////////////////////////////// 955 //////////////////////////////////////////////////////////////////////// 1461 // 956 // 1462 // Calculation of the PAI integral cross-sect 957 // Calculation of the PAI integral cross-section 1463 // fIntegralPAIxSection[1] = specific primary 958 // fIntegralPAIxSection[1] = specific primary ionisation, 1/cm 1464 // and fIntegralPAIxSection[0] = mean energy 959 // and fIntegralPAIxSection[0] = mean energy loss per cm in keV/cm 1465 960 1466 void G4PAIxSection::IntegralPAIxSection() 961 void G4PAIxSection::IntegralPAIxSection() 1467 { 962 { 1468 fIntegralPAIxSection[fSplineNumber] = 0; << 963 fIntegralPAIxSection[fSplineNumber] = 0 ; 1469 fIntegralPAIdEdx[fSplineNumber] = 0; << 964 fIntegralPAIdEdx[fSplineNumber] = 0 ; 1470 fIntegralPAIxSection[0] = 0; << 965 fIntegralPAIxSection[0] = 0 ; 1471 G4int i, k = fIntervalNumber -1; << 966 G4int k = fIntervalNumber -1 ; 1472 967 1473 for( i = fSplineNumber-1; i >= 1; i--) << 968 for(G4int i = fSplineNumber-1 ; i >= 1 ; i--) 1474 { 969 { 1475 if(fSplineEnergy[i] >= fEnergyInterval[k] 970 if(fSplineEnergy[i] >= fEnergyInterval[k]) 1476 { 971 { 1477 fIntegralPAIxSection[i] = fIntegralPAIx << 972 fIntegralPAIxSection[i] = fIntegralPAIxSection[i+1] + SumOverInterval(i) ; 1478 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[ << 973 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[i+1] + SumOverIntervaldEdx(i) ; 1479 } 974 } 1480 else 975 else 1481 { 976 { 1482 fIntegralPAIxSection[i] = fIntegralPAIx 977 fIntegralPAIxSection[i] = fIntegralPAIxSection[i+1] + 1483 SumOverBor << 978 SumOverBorder(i+1,fEnergyInterval[k]) ; 1484 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[ 979 fIntegralPAIdEdx[i] = fIntegralPAIdEdx[i+1] + 1485 SumOverBor << 980 SumOverBorderdEdx(i+1,fEnergyInterval[k]) ; 1486 k--; << 981 k-- ; 1487 } 982 } 1488 if(fVerbose>0) G4cout<<"i = "<<i<<"; k = << 1489 } 983 } 1490 } // end of IntegralPAIxSection 984 } // end of IntegralPAIxSection 1491 985 1492 ///////////////////////////////////////////// 986 //////////////////////////////////////////////////////////////////////// 1493 // 987 // 1494 // Calculation of the PAI Cerenkov integral c 988 // Calculation of the PAI Cerenkov integral cross-section 1495 // fIntegralCrenkov[1] = specific Crenkov ion 989 // fIntegralCrenkov[1] = specific Crenkov ionisation, 1/cm 1496 // and fIntegralCerenkov[0] = mean Cerenkov l 990 // and fIntegralCerenkov[0] = mean Cerenkov loss per cm in keV/cm 1497 991 1498 void G4PAIxSection::IntegralCerenkov() 992 void G4PAIxSection::IntegralCerenkov() 1499 { 993 { 1500 G4int i, k; << 994 G4int i, k ; 1501 fIntegralCerenkov[fSplineNumber] = 0; << 995 fIntegralCerenkov[fSplineNumber] = 0 ; 1502 fIntegralCerenkov[0] = 0; << 996 fIntegralCerenkov[0] = 0 ; 1503 k = fIntervalNumber -1; << 997 k = fIntervalNumber -1 ; 1504 998 1505 for( i = fSplineNumber-1; i >= 1; i-- ) << 999 for( i = fSplineNumber-1 ; i >= 1 ; i-- ) 1506 { 1000 { 1507 if(fSplineEnergy[i] >= fEnergyInterval[ 1001 if(fSplineEnergy[i] >= fEnergyInterval[k]) 1508 { 1002 { 1509 fIntegralCerenkov[i] = fIntegralCeren << 1003 fIntegralCerenkov[i] = fIntegralCerenkov[i+1] + SumOverInterCerenkov(i) ; 1510 // G4cout<<"int: i = "<<i<<"; sumC = << 1004 // G4cout<<"int: i = "<<i<<"; sumC = "<<fIntegralCerenkov[i]<<G4endl; 1511 } 1005 } 1512 else 1006 else 1513 { 1007 { 1514 fIntegralCerenkov[i] = fIntegralCeren 1008 fIntegralCerenkov[i] = fIntegralCerenkov[i+1] + 1515 SumOverBor << 1009 SumOverBordCerenkov(i+1,fEnergyInterval[k]) ; 1516 k--; << 1010 k-- ; 1517 // G4cout<<"bord: i = "<<i<<"; sumC = << 1011 // G4cout<<"bord: i = "<<i<<"; sumC = "<<fIntegralCerenkov[i]<<G4endl; 1518 } 1012 } 1519 } 1013 } 1520 1014 1521 } // end of IntegralCerenkov 1015 } // end of IntegralCerenkov 1522 1016 1523 ///////////////////////////////////////////// 1017 //////////////////////////////////////////////////////////////////////// 1524 // 1018 // 1525 // Calculation of the PAI MM-Cerenkov integra << 1526 // fIntegralMM[1] = specific MM-Cerenkov ioni << 1527 // and fIntegralMM[0] = mean MM-Cerenkov loss << 1528 << 1529 void G4PAIxSection::IntegralMM() << 1530 { << 1531 G4int i, k; << 1532 fIntegralMM[fSplineNumber] = 0; << 1533 fIntegralMM[0] = 0; << 1534 k = fIntervalNumber -1; << 1535 << 1536 for( i = fSplineNumber-1; i >= 1; i-- ) << 1537 { << 1538 if(fSplineEnergy[i] >= fEnergyInterval[ << 1539 { << 1540 fIntegralMM[i] = fIntegralMM[i+1] + S << 1541 // G4cout<<"int: i = "<<i<<"; sumC = << 1542 } << 1543 else << 1544 { << 1545 fIntegralMM[i] = fIntegralMM[i+1] + << 1546 SumOverBor << 1547 k--; << 1548 // G4cout<<"bord: i = "<<i<<"; sumC = << 1549 } << 1550 } << 1551 << 1552 } // end of IntegralMM << 1553 << 1554 ///////////////////////////////////////////// << 1555 // << 1556 // Calculation of the PAI Plasmon integral cr 1019 // Calculation of the PAI Plasmon integral cross-section 1557 // fIntegralPlasmon[1] = splasmon primary ion 1020 // fIntegralPlasmon[1] = splasmon primary ionisation, 1/cm 1558 // and fIntegralPlasmon[0] = mean plasmon los 1021 // and fIntegralPlasmon[0] = mean plasmon loss per cm in keV/cm 1559 1022 1560 void G4PAIxSection::IntegralPlasmon() 1023 void G4PAIxSection::IntegralPlasmon() 1561 { 1024 { 1562 fIntegralPlasmon[fSplineNumber] = 0; << 1025 fIntegralPlasmon[fSplineNumber] = 0 ; 1563 fIntegralPlasmon[0] = 0; << 1026 fIntegralPlasmon[0] = 0 ; 1564 G4int k = fIntervalNumber -1; << 1027 G4int k = fIntervalNumber -1 ; 1565 for(G4int i=fSplineNumber-1;i>=1;i--) 1028 for(G4int i=fSplineNumber-1;i>=1;i--) 1566 { 1029 { 1567 if(fSplineEnergy[i] >= fEnergyInterval[ 1030 if(fSplineEnergy[i] >= fEnergyInterval[k]) 1568 { 1031 { 1569 fIntegralPlasmon[i] = fIntegralPlasmo << 1032 fIntegralPlasmon[i] = fIntegralPlasmon[i+1] + SumOverInterPlasmon(i) ; 1570 } 1033 } 1571 else 1034 else 1572 { 1035 { 1573 fIntegralPlasmon[i] = fIntegralPlasmo 1036 fIntegralPlasmon[i] = fIntegralPlasmon[i+1] + 1574 SumOverBor << 1037 SumOverBordPlasmon(i+1,fEnergyInterval[k]) ; 1575 k--; << 1038 k-- ; 1576 } 1039 } 1577 } 1040 } 1578 1041 1579 } // end of IntegralPlasmon 1042 } // end of IntegralPlasmon 1580 1043 1581 ///////////////////////////////////////////// << 1582 // << 1583 // Calculation of the PAI resonance integral << 1584 // fIntegralResonance[1] = resonance primary << 1585 // and fIntegralResonance[0] = mean resonance << 1586 << 1587 void G4PAIxSection::IntegralResonance() << 1588 { << 1589 fIntegralResonance[fSplineNumber] = 0; << 1590 fIntegralResonance[0] = 0; << 1591 G4int k = fIntervalNumber -1; << 1592 for(G4int i=fSplineNumber-1;i>=1;i--) << 1593 { << 1594 if(fSplineEnergy[i] >= fEnergyInterval[ << 1595 { << 1596 fIntegralResonance[i] = fIntegralReso << 1597 } << 1598 else << 1599 { << 1600 fIntegralResonance[i] = fIntegralReso << 1601 SumOverBor << 1602 k--; << 1603 } << 1604 } << 1605 << 1606 } // end of IntegralResonance << 1607 << 1608 ///////////////////////////////////////////// 1044 ////////////////////////////////////////////////////////////////////// 1609 // 1045 // 1610 // Calculation the PAI integral cross-section 1046 // Calculation the PAI integral cross-section inside 1611 // of interval of continuous values of photo- 1047 // of interval of continuous values of photo-ionisation 1612 // cross-section. Parameter 'i' is the numbe 1048 // cross-section. Parameter 'i' is the number of interval. 1613 1049 1614 G4double G4PAIxSection::SumOverInterval( G4in 1050 G4double G4PAIxSection::SumOverInterval( G4int i ) 1615 { 1051 { 1616 G4double x0,x1,y0,yy1,a,b,c,result; << 1052 G4double x0,x1,y0,yy1,a,b,c,result ; 1617 << 1618 x0 = fSplineEnergy[i]; << 1619 x1 = fSplineEnergy[i+1]; << 1620 if(fVerbose>0) G4cout<<"SumOverInterval i= << 1621 1053 1622 if( x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/( << 1054 x0 = fSplineEnergy[i] ; 1623 << 1055 x1 = fSplineEnergy[i+1] ; 1624 y0 = fDifPAIxSection[i]; << 1056 y0 = fDifPAIxSection[i] ; 1625 yy1 = fDifPAIxSection[i+1]; 1057 yy1 = fDifPAIxSection[i+1]; 1626 << 1627 if(fVerbose>0) G4cout<<"x0 = "<<x0<<"; x1 << 1628 << 1629 c = x1/x0; 1058 c = x1/x0; 1630 a = log10(yy1/y0)/log10(c); << 1059 a = log10(yy1/y0)/log10(c) ; 1631 << 1060 // b = log10(y0) - a*log10(x0) ; 1632 if(fVerbose>0) G4cout<<"SumOverInterval, a << 1061 b = y0/pow(x0,a) ; 1633 << 1062 a += 1 ; 1634 b = 0.0; << 1063 if(a == 0) 1635 if(a < 20.) b = y0/pow(x0,a); << 1636 << 1637 a += 1.; << 1638 if( std::abs(a) < 1.e-6 ) << 1639 { 1064 { 1640 result = b*log(x1/x0); << 1065 result = b*log(x1/x0) ; 1641 } 1066 } 1642 else 1067 else 1643 { 1068 { 1644 result = y0*(x1*pow(c,a-1) - x0)/a; << 1069 result = y0*(x1*pow(c,a-1) - x0)/a ; 1645 } 1070 } 1646 a += 1.; << 1071 a++; 1647 if( std::abs(a) < 1.e-6 ) << 1072 if(a == 0) 1648 { 1073 { 1649 fIntegralPAIxSection[0] += b*log(x1/x0); << 1074 fIntegralPAIxSection[0] += b*log(x1/x0) ; 1650 } 1075 } 1651 else 1076 else 1652 { 1077 { 1653 fIntegralPAIxSection[0] += y0*(x1*x1*po << 1078 fIntegralPAIxSection[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a ; 1654 } 1079 } 1655 if(fVerbose>0) G4cout<<"SumOverInterval, r << 1080 return result ; 1656 return result; << 1657 1081 1658 } // end of SumOverInterval 1082 } // end of SumOverInterval 1659 1083 1660 ///////////////////////////////// 1084 ///////////////////////////////// 1661 1085 1662 G4double G4PAIxSection::SumOverIntervaldEdx( 1086 G4double G4PAIxSection::SumOverIntervaldEdx( G4int i ) 1663 { 1087 { 1664 G4double x0,x1,y0,yy1,a,b,c,result; << 1088 G4double x0,x1,y0,yy1,a,b,c,result ; 1665 << 1666 x0 = fSplineEnergy[i]; << 1667 x1 = fSplineEnergy[i+1]; << 1668 1089 1669 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x << 1090 x0 = fSplineEnergy[i] ; 1670 << 1091 x1 = fSplineEnergy[i+1] ; 1671 y0 = fDifPAIxSection[i]; << 1092 y0 = fDifPAIxSection[i] ; 1672 yy1 = fDifPAIxSection[i+1]; 1093 yy1 = fDifPAIxSection[i+1]; 1673 c = x1/x0; 1094 c = x1/x0; 1674 a = log10(yy1/y0)/log10(c); << 1095 a = log10(yy1/y0)/log10(c) ; 1675 << 1096 // b = log10(y0) - a*log10(x0) ; 1676 b = 0.0; << 1097 b = y0/pow(x0,a) ; 1677 if(a < 20.) b = y0/pow(x0,a); << 1098 a += 2 ; 1678 << 1679 a += 2; << 1680 if(a == 0) 1099 if(a == 0) 1681 { 1100 { 1682 result = b*log(x1/x0); << 1101 result = b*log(x1/x0) ; 1683 } 1102 } 1684 else 1103 else 1685 { 1104 { 1686 result = y0*(x1*x1*pow(c,a-2) - x0*x0)/a << 1105 result = y0*(x1*x1*pow(c,a-2) - x0*x0)/a ; 1687 } 1106 } 1688 return result; << 1107 return result ; 1689 1108 1690 } // end of SumOverInterval 1109 } // end of SumOverInterval 1691 1110 1692 ///////////////////////////////////////////// 1111 ////////////////////////////////////////////////////////////////////// 1693 // 1112 // 1694 // Calculation the PAI Cerenkov integral cros 1113 // Calculation the PAI Cerenkov integral cross-section inside 1695 // of interval of continuous values of photo- 1114 // of interval of continuous values of photo-ionisation Cerenkov 1696 // cross-section. Parameter 'i' is the numbe 1115 // cross-section. Parameter 'i' is the number of interval. 1697 1116 1698 G4double G4PAIxSection::SumOverInterCerenkov( 1117 G4double G4PAIxSection::SumOverInterCerenkov( G4int i ) 1699 { 1118 { 1700 G4double x0,x1,y0,yy1,a,b,c,result; << 1119 G4double x0,x1,y0,yy1,a,b,c,result ; 1701 << 1702 x0 = fSplineEnergy[i]; << 1703 x1 = fSplineEnergy[i+1]; << 1704 1120 1705 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x << 1121 x0 = fSplineEnergy[i] ; 1706 << 1122 x1 = fSplineEnergy[i+1] ; 1707 y0 = fdNdxCerenkov[i]; << 1123 y0 = fdNdxCerenkov[i] ; 1708 yy1 = fdNdxCerenkov[i+1]; 1124 yy1 = fdNdxCerenkov[i+1]; 1709 // G4cout<<"SumC, i = "<<i<<"; x0 ="<<x0<< 1125 // G4cout<<"SumC, i = "<<i<<"; x0 ="<<x0<<"; x1 = "<<x1 1710 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4e 1126 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl; 1711 1127 1712 c = x1/x0; 1128 c = x1/x0; 1713 a = log10(yy1/y0)/log10(c); << 1129 a = log10(yy1/y0)/log10(c) ; 1714 << 1130 b = y0/pow(x0,a) ; 1715 if(a > 20.0) b = 0.0; << 1716 else b = y0/pow(x0,a); << 1717 1131 1718 a += 1.0; << 1132 a += 1.0 ; 1719 if(a == 0) result = b*log(c); << 1133 if(a == 0) result = b*log(c) ; 1720 else result = y0*(x1*pow(c,a-1) - x0 << 1134 else result = y0*(x1*pow(c,a-1) - x0)/a ; 1721 a += 1.0; << 1135 a += 1.0 ; 1722 1136 1723 if( a == 0 ) fIntegralCerenkov[0] += b*log << 1137 if( a == 0 ) fIntegralCerenkov[0] += b*log(x1/x0) ; 1724 else fIntegralCerenkov[0] += y0*(x << 1138 else fIntegralCerenkov[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a ; 1725 // G4cout<<"a = "<<a<<"; b = "<<b<<"; res 1139 // G4cout<<"a = "<<a<<"; b = "<<b<<"; result = "<<result<<G4endl; 1726 return result; << 1140 return result ; 1727 1141 1728 } // end of SumOverInterCerenkov 1142 } // end of SumOverInterCerenkov 1729 1143 1730 ///////////////////////////////////////////// 1144 ////////////////////////////////////////////////////////////////////// 1731 // 1145 // 1732 // Calculation the PAI MM-Cerenkov integral c << 1733 // of interval of continuous values of photo- << 1734 // cross-section. Parameter 'i' is the numbe << 1735 << 1736 G4double G4PAIxSection::SumOverInterMM( G4int << 1737 { << 1738 G4double x0,x1,y0,yy1,a,b,c,result; << 1739 << 1740 x0 = fSplineEnergy[i]; << 1741 x1 = fSplineEnergy[i+1]; << 1742 << 1743 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x << 1744 << 1745 y0 = fdNdxMM[i]; << 1746 yy1 = fdNdxMM[i+1]; << 1747 //G4cout<<"SumC, i = "<<i<<"; x0 ="<<x0<<" << 1748 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4e << 1749 << 1750 c = x1/x0; << 1751 //G4cout<<" c = "<<c<< " yy1/y0= " << yy1/ << 1752 a = log10(yy1/y0)/log10(c); << 1753 << 1754 b = 0.0; << 1755 if(a < 20.) b = y0/pow(x0,a); << 1756 << 1757 a += 1.0; << 1758 if(a == 0) result = b*log(c); << 1759 else result = y0*(x1*pow(c,a-1) - x0 << 1760 a += 1.0; << 1761 << 1762 if( a == 0 ) fIntegralMM[0] += b*log(c); << 1763 else fIntegralMM[0] += y0*(x1*x1*p << 1764 //G4cout<<"a = "<<a<<"; b = "<<b<<"; resul << 1765 return result; << 1766 << 1767 } // end of SumOverInterMM << 1768 << 1769 ///////////////////////////////////////////// << 1770 // << 1771 // Calculation the PAI Plasmon integral cross 1146 // Calculation the PAI Plasmon integral cross-section inside 1772 // of interval of continuous values of photo- 1147 // of interval of continuous values of photo-ionisation Plasmon 1773 // cross-section. Parameter 'i' is the numbe 1148 // cross-section. Parameter 'i' is the number of interval. 1774 1149 1775 G4double G4PAIxSection::SumOverInterPlasmon( 1150 G4double G4PAIxSection::SumOverInterPlasmon( G4int i ) 1776 { 1151 { 1777 G4double x0,x1,y0,yy1,a,b,c,result; << 1152 G4double x0,x1,y0,yy1,a,b,c,result ; 1778 1153 1779 x0 = fSplineEnergy[i]; << 1154 x0 = fSplineEnergy[i] ; 1780 x1 = fSplineEnergy[i+1]; << 1155 x1 = fSplineEnergy[i+1] ; 1781 << 1156 y0 = fdNdxPlasmon[i] ; 1782 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x << 1783 << 1784 y0 = fdNdxPlasmon[i]; << 1785 yy1 = fdNdxPlasmon[i+1]; 1157 yy1 = fdNdxPlasmon[i+1]; 1786 c = x1/x0; << 1787 a = log10(yy1/y0)/log10(c); << 1788 << 1789 b = 0.0; << 1790 if(a < 20.) b = y0/pow(x0,a); << 1791 << 1792 a += 1.0; << 1793 if(a == 0) result = b*log(x1/x0); << 1794 else result = y0*(x1*pow(c,a-1) - x0 << 1795 a += 1.0; << 1796 << 1797 if( a == 0 ) fIntegralPlasmon[0] += b*log( << 1798 else fIntegralPlasmon[0] += y0*(x1 << 1799 << 1800 return result; << 1801 << 1802 } // end of SumOverInterPlasmon << 1803 << 1804 ///////////////////////////////////////////// << 1805 // << 1806 // Calculation the PAI resonance integral cro << 1807 // of interval of continuous values of photo- << 1808 // cross-section. Parameter 'i' is the numbe << 1809 << 1810 G4double G4PAIxSection::SumOverInterResonance << 1811 { << 1812 G4double x0,x1,y0,yy1,a,b,c,result; << 1813 << 1814 x0 = fSplineEnergy[i]; << 1815 x1 = fSplineEnergy[i+1]; << 1816 << 1817 if(x1+x0 <= 0.0 || std::abs( 2.*(x1-x0)/(x << 1818 << 1819 y0 = fdNdxResonance[i]; << 1820 yy1 = fdNdxResonance[i+1]; << 1821 c =x1/x0; 1158 c =x1/x0; 1822 a = log10(yy1/y0)/log10(c); << 1159 a = log10(yy1/y0)/log10(c) ; >> 1160 // b = log10(y0) - a*log10(x0) ; >> 1161 b = y0/pow(x0,a) ; >> 1162 >> 1163 a += 1.0 ; >> 1164 if(a == 0) result = b*log(x1/x0) ; >> 1165 else result = y0*(x1*pow(c,a-1) - x0)/a ; >> 1166 a += 1.0 ; 1823 1167 1824 b = 0.0; << 1168 if( a == 0 ) fIntegralPlasmon[0] += b*log(x1/x0) ; 1825 if(a < 20.) b = y0/pow(x0,a); << 1169 else fIntegralPlasmon[0] += y0*(x1*x1*pow(c,a-2) - x0*x0)/a ; 1826 << 1827 a += 1.0; << 1828 if(a == 0) result = b*log(x1/x0); << 1829 else result = y0*(x1*pow(c,a-1) - x0 << 1830 a += 1.0; << 1831 << 1832 if( a == 0 ) fIntegralResonance[0] += b*lo << 1833 else fIntegralResonance[0] += y0*( << 1834 1170 1835 return result; << 1171 return result ; 1836 1172 1837 } // end of SumOverInterResonance << 1173 } // end of SumOverInterPlasmon 1838 1174 1839 ///////////////////////////////////////////// 1175 /////////////////////////////////////////////////////////////////////////////// 1840 // 1176 // 1841 // Integration of PAI cross-section for the c 1177 // Integration of PAI cross-section for the case of 1842 // passing across border between intervals 1178 // passing across border between intervals 1843 1179 1844 G4double G4PAIxSection::SumOverBorder( G4int 1180 G4double G4PAIxSection::SumOverBorder( G4int i , 1845 G4doub 1181 G4double en0 ) 1846 { 1182 { 1847 G4double x0,x1,y0,yy1,a,b,/*c,*/d,e0,result << 1183 G4double x0,x1,y0,yy1,a,b,c,d,e0,result ; 1848 1184 1849 e0 = en0; << 1185 e0 = en0 ; 1850 x0 = fSplineEnergy[i]; << 1186 x0 = fSplineEnergy[i] ; 1851 x1 = fSplineEnergy[i+1]; << 1187 x1 = fSplineEnergy[i+1] ; 1852 y0 = fDifPAIxSection[i]; << 1188 y0 = fDifPAIxSection[i] ; 1853 yy1 = fDifPAIxSection[i+1]; << 1189 yy1 = fDifPAIxSection[i+1] ; 1854 1190 1855 //c = x1/x0; << 1191 c = x1/x0; 1856 d = e0/x0; 1192 d = e0/x0; 1857 a = log10(yy1/y0)/log10(x1/x0); << 1193 a = log10(yy1/y0)/log10(x1/x0) ; 1858 << 1194 // b0 = log10(y0) - a*log10(x0) ; 1859 if(fVerbose>0) G4cout<<"SumOverBorder, a = << 1195 b = y0/pow(x0,a); // pow(10.,b) ; 1860 << 1861 b = 0.0; << 1862 if(a < 20.) b = y0/pow(x0,a); << 1863 1196 1864 a += 1.; << 1197 a += 1 ; 1865 if( std::abs(a) < 1.e-6 ) << 1198 if(a == 0) 1866 { 1199 { 1867 result = b*log(x0/e0); << 1200 result = b*log(x0/e0) ; 1868 } 1201 } 1869 else 1202 else 1870 { 1203 { 1871 result = y0*(x0 - e0*pow(d,a-1))/a; << 1204 result = y0*(x0 - e0*pow(d,a-1))/a ; 1872 } 1205 } 1873 a += 1.; << 1206 a++ ; 1874 if( std::abs(a) < 1.e-6 ) << 1207 if(a == 0) 1875 { 1208 { 1876 fIntegralPAIxSection[0] += b*log(x0/e0) << 1209 fIntegralPAIxSection[0] += b*log(x0/e0) ; 1877 } 1210 } 1878 else 1211 else 1879 { 1212 { 1880 fIntegralPAIxSection[0] += y0*(x0*x0 - << 1213 fIntegralPAIxSection[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a ; 1881 } 1214 } 1882 x0 = fSplineEnergy[i - 1]; << 1215 x0 = fSplineEnergy[i - 1] ; 1883 x1 = fSplineEnergy[i - 2]; << 1216 x1 = fSplineEnergy[i - 2] ; 1884 y0 = fDifPAIxSection[i - 1]; << 1217 y0 = fDifPAIxSection[i - 1] ; 1885 yy1 = fDifPAIxSection[i - 2]; << 1218 yy1 = fDifPAIxSection[i - 2] ; 1886 1219 >> 1220 c = x1/x0; 1887 d = e0/x0; 1221 d = e0/x0; 1888 a = log10(yy1/y0)/log10(x1/x0); << 1222 a = log10(yy1/y0)/log10(x1/x0) ; 1889 << 1223 // b0 = log10(y0) - a*log10(x0) ; 1890 b = 0.0; << 1224 b = y0/pow(x0,a) ; 1891 if(a < 20.) b = y0/pow(x0,a); << 1225 a += 1 ; 1892 << 1226 if(a == 0) 1893 a += 1.; << 1894 if( std::abs(a) < 1.e-6 ) << 1895 { 1227 { 1896 result += b*log(e0/x0); << 1228 result += b*log(e0/x0) ; 1897 } 1229 } 1898 else 1230 else 1899 { 1231 { 1900 result += y0*(e0*pow(d,a-1) - x0)/a; << 1232 result += y0*(e0*pow(d,a-1) - x0)/a ; 1901 } 1233 } 1902 a += 1.; << 1234 a++ ; 1903 if( std::abs(a) < 1.e-6 ) << 1235 if(a == 0) 1904 { 1236 { 1905 fIntegralPAIxSection[0] += b*log(e0/x0) << 1237 fIntegralPAIxSection[0] += b*log(e0/x0) ; 1906 } 1238 } 1907 else 1239 else 1908 { 1240 { 1909 fIntegralPAIxSection[0] += y0*(e0*e0*po << 1241 fIntegralPAIxSection[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a ; 1910 } 1242 } 1911 return result; << 1243 return result ; 1912 1244 1913 } 1245 } 1914 1246 1915 ///////////////////////////////////////////// 1247 /////////////////////////////////////////////////////////////////////// 1916 1248 1917 G4double G4PAIxSection::SumOverBorderdEdx( G4 << 1249 G4double G4PAIxSection::SumOverBorderdEdx( G4int i , >> 1250 G4double en0 ) 1918 { 1251 { 1919 G4double x0,x1,y0,yy1,a,b,d,e0,result; << 1252 G4double x0,x1,y0,yy1,a,b,c,d,e0,result ; 1920 1253 1921 e0 = en0; << 1254 e0 = en0 ; 1922 x0 = fSplineEnergy[i]; << 1255 x0 = fSplineEnergy[i] ; 1923 x1 = fSplineEnergy[i+1]; << 1256 x1 = fSplineEnergy[i+1] ; 1924 y0 = fDifPAIxSection[i]; << 1257 y0 = fDifPAIxSection[i] ; 1925 yy1 = fDifPAIxSection[i+1]; << 1258 yy1 = fDifPAIxSection[i+1] ; 1926 1259 >> 1260 c = x1/x0; 1927 d = e0/x0; 1261 d = e0/x0; 1928 a = log10(yy1/y0)/log10(x1/x0); << 1262 a = log10(yy1/y0)/log10(x1/x0) ; 1929 << 1263 // b0 = log10(y0) - a*log10(x0) ; 1930 b = 0.0; << 1264 b = y0/pow(x0,a); // pow(10.,b) ; 1931 if(a < 20.) b = y0/pow(x0,a); << 1932 1265 1933 a += 2; << 1266 a += 2 ; 1934 if(a == 0) 1267 if(a == 0) 1935 { 1268 { 1936 result = b*log(x0/e0); << 1269 result = b*log(x0/e0) ; 1937 } 1270 } 1938 else 1271 else 1939 { 1272 { 1940 result = y0*(x0*x0 - e0*e0*pow(d,a-2))/ << 1273 result = y0*(x0*x0 - e0*e0*pow(d,a-2))/a ; 1941 } 1274 } 1942 x0 = fSplineEnergy[i - 1]; << 1275 x0 = fSplineEnergy[i - 1] ; 1943 x1 = fSplineEnergy[i - 2]; << 1276 x1 = fSplineEnergy[i - 2] ; 1944 y0 = fDifPAIxSection[i - 1]; << 1277 y0 = fDifPAIxSection[i - 1] ; 1945 yy1 = fDifPAIxSection[i - 2]; << 1278 yy1 = fDifPAIxSection[i - 2] ; 1946 1279 1947 // c = x1/x0; << 1280 c = x1/x0; 1948 d = e0/x0; 1281 d = e0/x0; 1949 a = log10(yy1/y0)/log10(x1/x0); << 1282 a = log10(yy1/y0)/log10(x1/x0) ; 1950 << 1283 // b0 = log10(y0) - a*log10(x0) ; 1951 b = 0.0; << 1284 b = y0/pow(x0,a) ; 1952 if(a < 20.) b = y0/pow(x0,a); << 1285 a += 2 ; 1953 << 1954 a += 2; << 1955 if(a == 0) 1286 if(a == 0) 1956 { 1287 { 1957 result += b*log(e0/x0); << 1288 result += b*log(e0/x0) ; 1958 } 1289 } 1959 else 1290 else 1960 { 1291 { 1961 result += y0*(e0*e0*pow(d,a-2) - x0*x0) << 1292 result += y0*(e0*e0*pow(d,a-2) - x0*x0)/a ; 1962 } 1293 } 1963 return result; << 1294 return result ; 1964 1295 1965 } 1296 } 1966 1297 1967 ///////////////////////////////////////////// 1298 /////////////////////////////////////////////////////////////////////////////// 1968 // 1299 // 1969 // Integration of Cerenkov cross-section for 1300 // Integration of Cerenkov cross-section for the case of 1970 // passing across border between intervals 1301 // passing across border between intervals 1971 1302 1972 G4double G4PAIxSection::SumOverBordCerenkov( << 1303 G4double G4PAIxSection::SumOverBordCerenkov( G4int i , 1973 { << 1304 G4double en0 ) 1974 G4double x0,x1,y0,yy1,a,b,e0,c,d,result; << 1975 << 1976 e0 = en0; << 1977 x0 = fSplineEnergy[i]; << 1978 x1 = fSplineEnergy[i+1]; << 1979 y0 = fdNdxCerenkov[i]; << 1980 yy1 = fdNdxCerenkov[i+1]; << 1981 << 1982 //G4cout<<"SumBordC, i = "<<i<<"; en0 = "< << 1983 //<<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl << 1984 c = x1/x0; << 1985 d = e0/x0; << 1986 a = log10(yy1/y0)/log10(c); << 1987 //G4cout << " a= " << a << " c=" << c < << 1988 << 1989 b = 0.0; << 1990 if(a < 20.) b = y0/pow(x0,a); << 1991 << 1992 a += 1.0; << 1993 if( a == 0 ) result = b*log(x0/e0); << 1994 else result = y0*(x0 - e0*pow(d,a- << 1995 a += 1.0; << 1996 << 1997 if( a == 0 ) fIntegralCerenkov[0] += b*log << 1998 else fIntegralCerenkov[0] += y0*(x << 1999 << 2000 x0 = fSplineEnergy[i - 1]; << 2001 x1 = fSplineEnergy[i - 2]; << 2002 y0 = fdNdxCerenkov[i - 1]; << 2003 yy1 = fdNdxCerenkov[i - 2]; << 2004 << 2005 // G4cout<<"x0 ="<<x0<<"; x1 = "<<x1 << 2006 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4 << 2007 << 2008 c = x1/x0; << 2009 d = e0/x0; << 2010 a = log10(yy1/y0)/log10(c); << 2011 << 2012 b = 0.0; << 2013 if(a < 20.) b = y0/pow(x0,a); << 2014 << 2015 a += 1.0; << 2016 if( a == 0 ) result += b*log(e0/x0); << 2017 else result += y0*(e0*pow(d,a-1) - << 2018 a += 1.0; << 2019 << 2020 if( a == 0 ) fIntegralCerenkov[0] += b*log << 2021 else fIntegralCerenkov[0] += y0*(e << 2022 << 2023 //G4cout<<" a="<< a <<" b="<< b <<" res << 2024 return result; << 2025 } << 2026 << 2027 ///////////////////////////////////////////// << 2028 // << 2029 // Integration of MM-Cerenkov cross-section f << 2030 // passing across border between intervals << 2031 << 2032 G4double G4PAIxSection::SumOverBordMM( G4int << 2033 { 1305 { 2034 G4double x0,x1,y0,yy1,a,b,e0,c,d,result; << 1306 G4double x0,x1,y0,yy1,a,b,e0,c,d,result ; 2035 1307 2036 e0 = en0; << 1308 e0 = en0 ; 2037 x0 = fSplineEnergy[i]; << 1309 x0 = fSplineEnergy[i] ; 2038 x1 = fSplineEnergy[i+1]; << 1310 x1 = fSplineEnergy[i+1] ; 2039 y0 = fdNdxMM[i]; << 1311 y0 = fdNdxCerenkov[i] ; 2040 yy1 = fdNdxMM[i+1]; << 1312 yy1 = fdNdxCerenkov[i+1] ; 2041 1313 >> 1314 // G4cout<<G4endl; 2042 // G4cout<<"SumBordC, i = "<<i<<"; en0 = 1315 // G4cout<<"SumBordC, i = "<<i<<"; en0 = "<<en0<<"; x0 ="<<x0<<"; x1 = "<<x1 2043 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G 1316 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl; 2044 c = x1/x0; << 1317 c = x1/x0 ; 2045 d = e0/x0; << 1318 d = e0/x0 ; 2046 a = log10(yy1/y0)/log10(c); << 1319 a = log10(yy1/y0)/log10(c) ; 2047 << 1320 // b0 = log10(y0) - a*log10(x0) ; 2048 if(a > 20.0) b = 0.0; << 1321 b = y0/pow(x0,a); // pow(10.,b0) ; 2049 else b = y0/pow(x0,a); << 1322 2050 << 1323 a += 1.0 ; 2051 a += 1.0; << 1324 if( a == 0 ) result = b*log(x0/e0) ; 2052 if( a == 0 ) result = b*log(x0/e0); << 1325 else result = y0*(x0 - e0*pow(d,a-1))/a ; 2053 else result = y0*(x0 - e0*pow(d,a- << 1326 a += 1.0 ; 2054 a += 1.0; << 1327 2055 << 1328 if( a == 0 ) fIntegralCerenkov[0] += b*log(x0/e0) ; 2056 if( a == 0 ) fIntegralMM[0] += b*log(x0/e0 << 1329 else fIntegralCerenkov[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a ; 2057 else fIntegralMM[0] += y0*(x0*x0 - << 1330 2058 << 1331 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b = "<<b<<"; result = "<<result<<G4endl; 2059 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b << 1332 2060 << 1333 x0 = fSplineEnergy[i - 1] ; 2061 x0 = fSplineEnergy[i - 1]; << 1334 x1 = fSplineEnergy[i - 2] ; 2062 x1 = fSplineEnergy[i - 2]; << 1335 y0 = fdNdxCerenkov[i - 1] ; 2063 y0 = fdNdxMM[i - 1]; << 1336 yy1 = fdNdxCerenkov[i - 2] ; 2064 yy1 = fdNdxMM[i - 2]; << 2065 1337 2066 // G4cout<<"x0 ="<<x0<<"; x1 = "<<x1 1338 // G4cout<<"x0 ="<<x0<<"; x1 = "<<x1 2067 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4 1339 // <<"; y0 = "<<y0<<"; yy1 = "<<yy1<<G4endl; 2068 1340 2069 c = x1/x0; << 1341 c = x1/x0 ; 2070 d = e0/x0; << 1342 d = e0/x0 ; 2071 a = log10(yy1/y0)/log10(x1/x0); << 1343 a = log10(yy1/y0)/log10(x1/x0) ; 2072 << 1344 // b0 = log10(y0) - a*log10(x0) ; 2073 if(a > 20.0) b = 0.0; << 1345 b = y0/pow(x0,a); // pow(10.,b0) ; 2074 else b = y0/pow(x0,a); << 1346 2075 << 1347 a += 1.0 ; 2076 a += 1.0; << 1348 if( a == 0 ) result += b*log(e0/x0) ; 2077 if( a == 0 ) result += b*log(e0/x0); << 1349 else result += y0*(e0*pow(d,a-1) - x0 )/a ; 2078 else result += y0*(e0*pow(d,a-1) - << 1350 a += 1.0 ; 2079 a += 1.0; << 2080 1351 2081 if( a == 0 ) fIntegralMM[0] += b*log(e0/x0 << 1352 if( a == 0 ) fIntegralCerenkov[0] += b*log(e0/x0) ; 2082 else fIntegralMM[0] += y0*(e0*e0*p << 1353 else fIntegralCerenkov[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a ; 2083 1354 2084 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b 1355 // G4cout<<"a = "<<a<<"; b0 = "<<b0<<"; b = " 2085 // <<b<<"; result = "<<result<<G4endl; 1356 // <<b<<"; result = "<<result<<G4endl; 2086 1357 2087 return result; << 1358 return result ; 2088 1359 2089 } 1360 } 2090 1361 2091 ///////////////////////////////////////////// 1362 /////////////////////////////////////////////////////////////////////////////// 2092 // 1363 // 2093 // Integration of Plasmon cross-section for t 1364 // Integration of Plasmon cross-section for the case of 2094 // passing across border between intervals 1365 // passing across border between intervals 2095 1366 2096 G4double G4PAIxSection::SumOverBordPlasmon( G 1367 G4double G4PAIxSection::SumOverBordPlasmon( G4int i , 2097 1368 G4double en0 ) 2098 { 1369 { 2099 G4double x0,x1,y0,yy1,a,b,c,d,e0,result; << 1370 G4double x0,x1,y0,yy1,a,b,c,d,e0,result ; 2100 1371 2101 e0 = en0; << 1372 e0 = en0 ; 2102 x0 = fSplineEnergy[i]; << 1373 x0 = fSplineEnergy[i] ; 2103 x1 = fSplineEnergy[i+1]; << 1374 x1 = fSplineEnergy[i+1] ; 2104 y0 = fdNdxPlasmon[i]; << 1375 y0 = fdNdxPlasmon[i] ; 2105 yy1 = fdNdxPlasmon[i+1]; << 1376 yy1 = fdNdxPlasmon[i+1] ; >> 1377 >> 1378 c = x1/x0 ; >> 1379 d = e0/x0 ; >> 1380 a = log10(yy1/y0)/log10(c) ; >> 1381 // b0 = log10(y0) - a*log10(x0) ; >> 1382 b = y0/pow(x0,a); //pow(10.,b) ; >> 1383 >> 1384 a += 1.0 ; >> 1385 if( a == 0 ) result = b*log(x0/e0) ; >> 1386 else result = y0*(x0 - e0*pow(d,a-1))/a ; >> 1387 a += 1.0 ; >> 1388 >> 1389 if( a == 0 ) fIntegralPlasmon[0] += b*log(x0/e0) ; >> 1390 else fIntegralPlasmon[0] += y0*(x0*x0 - e0*e0*pow(d,a-2))/a ; >> 1391 >> 1392 x0 = fSplineEnergy[i - 1] ; >> 1393 x1 = fSplineEnergy[i - 2] ; >> 1394 y0 = fdNdxPlasmon[i - 1] ; >> 1395 yy1 = fdNdxPlasmon[i - 2] ; >> 1396 >> 1397 c = x1/x0 ; >> 1398 d = e0/x0 ; >> 1399 a = log10(yy1/y0)/log10(c) ; >> 1400 // b0 = log10(y0) - a*log10(x0) ; >> 1401 b = y0/pow(x0,a);// pow(10.,b0) ; >> 1402 >> 1403 a += 1.0 ; >> 1404 if( a == 0 ) result += b*log(e0/x0) ; >> 1405 else result += y0*(e0*pow(d,a-1) - x0)/a ; >> 1406 a += 1.0 ; 2106 1407 2107 c = x1/x0; << 1408 if( a == 0 ) fIntegralPlasmon[0] += b*log(e0/x0) ; 2108 d = e0/x0; << 1409 else fIntegralPlasmon[0] += y0*(e0*e0*pow(d,a-2) - x0*x0)/a ; 2109 a = log10(yy1/y0)/log10(c); << 2110 << 2111 if(a > 20.0) b = 0.0; << 2112 else b = y0/pow(x0,a); << 2113 1410 2114 a += 1.0; << 1411 return result ; 2115 if( a == 0 ) result = b*log(x0/e0); << 2116 else result = y0*(x0 - e0*pow(d,a- << 2117 a += 1.0; << 2118 << 2119 if( a == 0 ) fIntegralPlasmon[0] += b*log( << 2120 else fIntegralPlasmon[0] += y0*(x0 << 2121 << 2122 x0 = fSplineEnergy[i - 1]; << 2123 x1 = fSplineEnergy[i - 2]; << 2124 y0 = fdNdxPlasmon[i - 1]; << 2125 yy1 = fdNdxPlasmon[i - 2]; << 2126 << 2127 c = x1/x0; << 2128 d = e0/x0; << 2129 a = log10(yy1/y0)/log10(c); << 2130 << 2131 if(a > 20.0) b = 0.0; << 2132 else b = y0/pow(x0,a); << 2133 << 2134 a += 1.0; << 2135 if( a == 0 ) result += b*log(e0/x0); << 2136 else result += y0*(e0*pow(d,a-1) - << 2137 a += 1.0; << 2138 << 2139 if( a == 0 ) fIntegralPlasmon[0] += b*lo << 2140 else fIntegralPlasmon[0] += y0*( << 2141 << 2142 return result; << 2143 } << 2144 << 2145 ///////////////////////////////////////////// << 2146 // << 2147 // Integration of resonance cross-section for << 2148 // passing across border between intervals << 2149 << 2150 G4double G4PAIxSection::SumOverBordResonance( << 2151 << 2152 { << 2153 G4double x0,x1,y0,yy1,a,b,c,d,e0,result; << 2154 << 2155 e0 = en0; << 2156 x0 = fSplineEnergy[i]; << 2157 x1 = fSplineEnergy[i+1]; << 2158 y0 = fdNdxResonance[i]; << 2159 yy1 = fdNdxResonance[i+1]; << 2160 << 2161 c = x1/x0; << 2162 d = e0/x0; << 2163 a = log10(yy1/y0)/log10(c); << 2164 << 2165 if(a > 20.0) b = 0.0; << 2166 else b = y0/pow(x0,a); << 2167 << 2168 a += 1.0; << 2169 if( a == 0 ) result = b*log(x0/e0); << 2170 else result = y0*(x0 - e0*pow(d,a- << 2171 a += 1.0; << 2172 << 2173 if( a == 0 ) fIntegralResonance[0] += b*lo << 2174 else fIntegralResonance[0] += y0*( << 2175 << 2176 x0 = fSplineEnergy[i - 1]; << 2177 x1 = fSplineEnergy[i - 2]; << 2178 y0 = fdNdxResonance[i - 1]; << 2179 yy1 = fdNdxResonance[i - 2]; << 2180 << 2181 c = x1/x0; << 2182 d = e0/x0; << 2183 a = log10(yy1/y0)/log10(c); << 2184 << 2185 if(a > 20.0) b = 0.0; << 2186 else b = y0/pow(x0,a); << 2187 << 2188 a += 1.0; << 2189 if( a == 0 ) result += b*log(e0/x0); << 2190 else result += y0*(e0*pow(d,a-1) - << 2191 a += 1.0; << 2192 << 2193 if( a == 0 ) fIntegralResonance[0] += b*lo << 2194 else fIntegralResonance[0] += y0*( << 2195 << 2196 return result; << 2197 1412 2198 } 1413 } 2199 1414 2200 ///////////////////////////////////////////// 1415 ///////////////////////////////////////////////////////////////////////// 2201 // 1416 // 2202 // Returns random PAI-total energy loss over << 1417 // 2203 1418 2204 G4double G4PAIxSection::GetStepEnergyLoss( G4 1419 G4double G4PAIxSection::GetStepEnergyLoss( G4double step ) 2205 { 1420 { 2206 G4long numOfCollisions; << 1421 G4int iTransfer ; 2207 G4double meanNumber, loss = 0.0; << 1422 G4long numOfCollisions ; 2208 << 1423 G4double loss = 0.0 ; 2209 // G4cout<<" G4PAIxSection::GetStepEnergyLo << 1424 G4double meanNumber, position ; 2210 1425 2211 meanNumber = fIntegralPAIxSection[1]*step; << 1426 // G4cout<<" G4PAIxSection::GetStepEnergyLoss "<<G4endl ; 2212 numOfCollisions = G4Poisson(meanNumber); << 2213 1427 2214 // G4cout<<"numOfCollisions = "<<numOfColli << 2215 1428 2216 while(numOfCollisions) << 2217 { << 2218 loss += GetEnergyTransfer(); << 2219 numOfCollisions--; << 2220 // Loop checking, 03-Aug-2015, Vladimir I << 2221 } << 2222 // G4cout<<"PAI energy loss = "<<loss/keV<< << 2223 << 2224 return loss; << 2225 } << 2226 << 2227 ///////////////////////////////////////////// << 2228 // << 2229 // Returns random PAI-total energy transfer i << 2230 << 2231 G4double G4PAIxSection::GetEnergyTransfer() << 2232 { << 2233 G4int iTransfer ; << 2234 1429 2235 G4double energyTransfer, position; << 1430 meanNumber = fIntegralPAIxSection[1]*step ; >> 1431 numOfCollisions = G4Poisson(meanNumber) ; 2236 1432 2237 position = fIntegralPAIxSection[1]*G4Unifor << 1433 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl ; 2238 1434 2239 for( iTransfer = 1; iTransfer <= fSplineNum << 1435 while(numOfCollisions) 2240 { 1436 { 2241 if( position >= fIntegralPAIxSection[iTra << 1437 position = fIntegralPAIxSection[1]*G4UniformRand() ; 2242 } << 2243 if(iTransfer > fSplineNumber) iTransfer--; << 2244 << 2245 energyTransfer = fSplineEnergy[iTransfer]; << 2246 1438 2247 if(iTransfer > 1) << 1439 for( iTransfer=1 ; iTransfer<=fSplineNumber ; iTransfer++ ) 2248 { << 1440 { 2249 energyTransfer -= (fSplineEnergy[iTransfe << 1441 if( position >= fIntegralPAIxSection[iTransfer] ) break ; >> 1442 } >> 1443 loss += fSplineEnergy[iTransfer] ; >> 1444 numOfCollisions-- ; 2250 } 1445 } 2251 return energyTransfer; << 1446 // G4cout<<"PAI energy loss = "<<loss/keV<<" keV"<<G4endl ; >> 1447 >> 1448 return loss ; 2252 } 1449 } 2253 1450 2254 ///////////////////////////////////////////// 1451 ///////////////////////////////////////////////////////////////////////// 2255 // 1452 // 2256 // Returns random Cerenkov energy loss over s << 1453 // 2257 1454 2258 G4double G4PAIxSection::GetStepCerenkovLoss( 1455 G4double G4PAIxSection::GetStepCerenkovLoss( G4double step ) 2259 { 1456 { 2260 G4long numOfCollisions; << 1457 G4int iTransfer ; 2261 G4double meanNumber, loss = 0.0; << 1458 G4long numOfCollisions ; >> 1459 G4double loss = 0.0 ; >> 1460 G4double meanNumber, position ; 2262 1461 2263 // G4cout<<" G4PAIxSection::GetStepCerenkov << 1462 // G4cout<<" G4PAIxSection::GetStepCreLosnkovs "<<G4endl ; 2264 1463 2265 meanNumber = fIntegralCerenkov[1]*step; << 2266 numOfCollisions = G4Poisson(meanNumber); << 2267 1464 2268 // G4cout<<"numOfCollisions = "<<numOfCol << 2269 1465 2270 while(numOfCollisions) << 1466 meanNumber = fIntegralCerenkov[1]*step ; 2271 { << 1467 numOfCollisions = G4Poisson(meanNumber) ; 2272 loss += GetCerenkovEnergyTransfer(); << 2273 numOfCollisions--; << 2274 // Loop checking, 03-Aug-2015, Vladimir I << 2275 } << 2276 // G4cout<<"PAI Cerenkov loss = "<<loss/keV << 2277 << 2278 return loss; << 2279 } << 2280 << 2281 ///////////////////////////////////////////// << 2282 // << 2283 // Returns random MM-Cerenkov energy loss ove << 2284 << 2285 G4double G4PAIxSection::GetStepMMLoss( G4doub << 2286 { << 2287 G4long numOfCollisions; << 2288 G4double meanNumber, loss = 0.0; << 2289 << 2290 // G4cout<<" G4PAIxSection::GetStepMMLoss " << 2291 << 2292 meanNumber = fIntegralMM[1]*step; << 2293 numOfCollisions = G4Poisson(meanNumber); << 2294 1468 2295 // G4cout<<"numOfCollisions = "<<numOfCol << 1469 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl ; 2296 1470 2297 while(numOfCollisions) 1471 while(numOfCollisions) 2298 { 1472 { 2299 loss += GetMMEnergyTransfer(); << 1473 position = fIntegralCerenkov[1]*G4UniformRand() ; 2300 numOfCollisions--; << 2301 // Loop checking, 03-Aug-2015, Vladimir I << 2302 } << 2303 // G4cout<<"PAI MM-Cerenkov loss = "<<loss/ << 2304 << 2305 return loss; << 2306 } << 2307 << 2308 ///////////////////////////////////////////// << 2309 // << 2310 // Returns Cerenkov energy transfer in one co << 2311 1474 2312 G4double G4PAIxSection::GetCerenkovEnergyTran << 1475 for( iTransfer=1 ; iTransfer<=fSplineNumber ; iTransfer++ ) 2313 { << 1476 { 2314 G4int iTransfer ; << 1477 if( position >= fIntegralCerenkov[iTransfer] ) break ; 2315 << 1478 } 2316 G4double energyTransfer, position; << 1479 loss += fSplineEnergy[iTransfer] ; 2317 << 1480 numOfCollisions-- ; 2318 position = fIntegralCerenkov[1]*G4UniformRa << 2319 << 2320 for( iTransfer = 1; iTransfer <= fSplineNum << 2321 { << 2322 if( position >= fIntegralCerenkov[iTr << 2323 } 1481 } 2324 if(iTransfer > fSplineNumber) iTransfer--; << 1482 // G4cout<<"PAI Cerenkov loss = "<<loss/keV<<" keV"<<G4endl ; 2325 << 2326 energyTransfer = fSplineEnergy[iTransfer]; << 2327 1483 2328 if(iTransfer > 1) << 1484 return loss ; 2329 { << 2330 energyTransfer -= (fSplineEnergy[iTransfe << 2331 } << 2332 return energyTransfer; << 2333 } 1485 } 2334 1486 2335 ///////////////////////////////////////////// 1487 ///////////////////////////////////////////////////////////////////////// 2336 // 1488 // 2337 // Returns MM-Cerenkov energy transfer in one << 2338 << 2339 G4double G4PAIxSection::GetMMEnergyTransfer() << 2340 { << 2341 G4int iTransfer ; << 2342 << 2343 G4double energyTransfer, position; << 2344 << 2345 position = fIntegralMM[1]*G4UniformRand(); << 2346 << 2347 for( iTransfer = 1; iTransfer <= fSplineNum << 2348 { << 2349 if( position >= fIntegralMM[iTransfer] ) << 2350 } << 2351 if(iTransfer > fSplineNumber) iTransfer--; << 2352 << 2353 energyTransfer = fSplineEnergy[iTransfer]; << 2354 << 2355 if(iTransfer > 1) << 2356 { << 2357 energyTransfer -= (fSplineEnergy[iTransfe << 2358 } << 2359 return energyTransfer; << 2360 } << 2361 << 2362 ///////////////////////////////////////////// << 2363 // 1489 // 2364 // Returns random plasmon energy loss over st << 2365 1490 2366 G4double G4PAIxSection::GetStepPlasmonLoss( G 1491 G4double G4PAIxSection::GetStepPlasmonLoss( G4double step ) 2367 { 1492 { 2368 G4long numOfCollisions; << 1493 G4int iTransfer ; 2369 G4double meanNumber, loss = 0.0; << 1494 G4long numOfCollisions ; 2370 << 1495 G4double loss = 0.0 ; 2371 // G4cout<<" G4PAIxSection::GetStepPlasmonL << 1496 G4double meanNumber, position ; 2372 << 2373 meanNumber = fIntegralPlasmon[1]*step; << 2374 numOfCollisions = G4Poisson(meanNumber); << 2375 << 2376 // G4cout<<"numOfCollisions = "<<numOfCol << 2377 << 2378 while(numOfCollisions) << 2379 { << 2380 loss += GetPlasmonEnergyTransfer(); << 2381 numOfCollisions--; << 2382 // Loop checking, 03-Aug-2015, Vladimir I << 2383 } << 2384 // G4cout<<"PAI Plasmon loss = "<<loss/keV< << 2385 << 2386 return loss; << 2387 } << 2388 << 2389 ///////////////////////////////////////////// << 2390 // << 2391 // Returns plasmon energy transfer in one col << 2392 << 2393 G4double G4PAIxSection::GetPlasmonEnergyTrans << 2394 { << 2395 G4int iTransfer ; << 2396 << 2397 G4double energyTransfer, position; << 2398 << 2399 position = fIntegralPlasmon[1]*G4UniformRan << 2400 << 2401 for( iTransfer = 1; iTransfer <= fSplineNum << 2402 { << 2403 if( position >= fIntegralPlasmon[iTransfe << 2404 } << 2405 if(iTransfer > fSplineNumber) iTransfer--; << 2406 << 2407 energyTransfer = fSplineEnergy[iTransfer]; << 2408 1497 2409 if(iTransfer > 1) << 1498 // G4cout<<" G4PAIxSection::GetStepCreLosnkovs "<<G4endl ; 2410 { << 2411 energyTransfer -= (fSplineEnergy[iTransfe << 2412 } << 2413 return energyTransfer; << 2414 } << 2415 1499 2416 ///////////////////////////////////////////// << 2417 // << 2418 // Returns random resonance energy loss over << 2419 1500 2420 G4double G4PAIxSection::GetStepResonanceLoss( << 2421 { << 2422 G4long numOfCollisions; << 2423 G4double meanNumber, loss = 0.0; << 2424 << 2425 // G4cout<<" G4PAIxSection::GetStepCreLosnk << 2426 1501 2427 meanNumber = fIntegralResonance[1]*step; << 1502 meanNumber = fIntegralPlasmon[1]*step ; 2428 numOfCollisions = G4Poisson(meanNumber); << 1503 numOfCollisions = G4Poisson(meanNumber) ; 2429 1504 2430 // G4cout<<"numOfCollisions = "<<numOfCol << 1505 // G4cout<<"numOfCollisions = "<<numOfCollisions<<G4endl ; 2431 1506 2432 while(numOfCollisions) 1507 while(numOfCollisions) 2433 { 1508 { 2434 loss += GetResonanceEnergyTransfer(); << 1509 position = fIntegralPlasmon[1]*G4UniformRand() ; 2435 numOfCollisions--; << 2436 // Loop checking, 03-Aug-2015, Vladimir I << 2437 } << 2438 // G4cout<<"PAI resonance loss = "<<loss/ke << 2439 1510 2440 return loss; << 1511 for( iTransfer=1 ; iTransfer<=fSplineNumber ; iTransfer++ ) 2441 } << 1512 { 2442 << 1513 if( position >= fIntegralPlasmon[iTransfer] ) break ; 2443 << 1514 } 2444 ///////////////////////////////////////////// << 1515 loss += fSplineEnergy[iTransfer] ; 2445 // << 1516 numOfCollisions-- ; 2446 // Returns resonance energy transfer in one c << 2447 << 2448 G4double G4PAIxSection::GetResonanceEnergyTra << 2449 { << 2450 G4int iTransfer ; << 2451 << 2452 G4double energyTransfer, position; << 2453 << 2454 position = fIntegralResonance[1]*G4UniformR << 2455 << 2456 for( iTransfer = 1; iTransfer <= fSplineNum << 2457 { << 2458 if( position >= fIntegralResonance[iTrans << 2459 } << 2460 if(iTransfer > fSplineNumber) iTransfer--; << 2461 << 2462 energyTransfer = fSplineEnergy[iTransfer]; << 2463 << 2464 if(iTransfer > 1) << 2465 { << 2466 energyTransfer -= (fSplineEnergy[iTransfe << 2467 } << 2468 return energyTransfer; << 2469 } << 2470 << 2471 << 2472 ///////////////////////////////////////////// << 2473 // << 2474 // Returns Rutherford energy transfer in one << 2475 << 2476 G4double G4PAIxSection::GetRutherfordEnergyTr << 2477 { << 2478 G4int iTransfer ; << 2479 << 2480 G4double energyTransfer, position; << 2481 << 2482 position = (fIntegralPlasmon[1]-fIntegralRe << 2483 << 2484 for( iTransfer = 1; iTransfer <= fSplineNum << 2485 { << 2486 if( position >= (fIntegralPlasmon[iTransf << 2487 } 1517 } 2488 if(iTransfer > fSplineNumber) iTransfer--; << 1518 // G4cout<<"PAI Plasmon loss = "<<loss/keV<<" keV"<<G4endl ; 2489 << 2490 energyTransfer = fSplineEnergy[iTransfer]; << 2491 1519 2492 if(iTransfer > 1) << 1520 return loss ; 2493 { << 2494 energyTransfer -= (fSplineEnergy[iTransfe << 2495 } << 2496 return energyTransfer; << 2497 } 1521 } 2498 1522 2499 ///////////////////////////////////////////// << 2500 // << 2501 1523 2502 void G4PAIxSection::CallError(G4int i, const << 2503 { << 2504 G4String head = "G4PAIxSection::" + methodN << 2505 G4ExceptionDescription ed; << 2506 ed << "Wrong index " << i << " fSplineNumbe << 2507 G4Exception(head,"pai001",FatalException,ed << 2508 } << 2509 1524 2510 ///////////////////////////////////////////// 1525 ///////////////////////////////////////////////////////////////////////////// 2511 // 1526 // 2512 // Init array of Lorentz factors 1527 // Init array of Lorentz factors 2513 // 1528 // 2514 1529 2515 G4int G4PAIxSection::fNumberOfGammas = 111; << 1530 G4int G4PAIxSection::fNumberOfGammas = 111 ; 2516 1531 2517 const G4double G4PAIxSection::fLorentzFactor[ 1532 const G4double G4PAIxSection::fLorentzFactor[112] = // fNumberOfGammas+1 2518 { 1533 { 2519 0.0, 1534 0.0, 2520 1.094989e+00, 1.107813e+00, 1.122369e+00, 1.1 1535 1.094989e+00, 1.107813e+00, 1.122369e+00, 1.138890e+00, 1.157642e+00, 2521 1.178925e+00, 1.203082e+00, 1.230500e+00, 1.2 1536 1.178925e+00, 1.203082e+00, 1.230500e+00, 1.261620e+00, 1.296942e+00, // 10 2522 1.337032e+00, 1.382535e+00, 1.434181e+00, 1.4 1537 1.337032e+00, 1.382535e+00, 1.434181e+00, 1.492800e+00, 1.559334e+00, 2523 1.634850e+00, 1.720562e+00, 1.817845e+00, 1.9 1538 1.634850e+00, 1.720562e+00, 1.817845e+00, 1.928263e+00, 2.053589e+00, // 20 2524 2.195835e+00, 2.357285e+00, 2.540533e+00, 2.7 1539 2.195835e+00, 2.357285e+00, 2.540533e+00, 2.748522e+00, 2.984591e+00, 2525 3.252533e+00, 3.556649e+00, 3.901824e+00, 4.2 1540 3.252533e+00, 3.556649e+00, 3.901824e+00, 4.293602e+00, 4.738274e+00, // 30 2526 5.242981e+00, 5.815829e+00, 6.466019e+00, 7.2 1541 5.242981e+00, 5.815829e+00, 6.466019e+00, 7.203990e+00, 8.041596e+00, 2527 8.992288e+00, 1.007133e+01, 1.129606e+01, 1.2 1542 8.992288e+00, 1.007133e+01, 1.129606e+01, 1.268614e+01, 1.426390e+01, // 40 2528 1.605467e+01, 1.808721e+01, 2.039417e+01, 2.3 1543 1.605467e+01, 1.808721e+01, 2.039417e+01, 2.301259e+01, 2.598453e+01, 2529 2.935771e+01, 3.318630e+01, 3.753180e+01, 4.2 1544 2.935771e+01, 3.318630e+01, 3.753180e+01, 4.246399e+01, 4.806208e+01, // 50 2530 5.441597e+01, 6.162770e+01, 6.981310e+01, 7.9 1545 5.441597e+01, 6.162770e+01, 6.981310e+01, 7.910361e+01, 8.964844e+01, 2531 1.016169e+02, 1.152013e+02, 1.306197e+02, 1.4 1546 1.016169e+02, 1.152013e+02, 1.306197e+02, 1.481198e+02, 1.679826e+02, // 60 2532 1.905270e+02, 2.161152e+02, 2.451581e+02, 2.7 1547 1.905270e+02, 2.161152e+02, 2.451581e+02, 2.781221e+02, 3.155365e+02, 2533 3.580024e+02, 4.062016e+02, 4.609081e+02, 5.2 1548 3.580024e+02, 4.062016e+02, 4.609081e+02, 5.230007e+02, 5.934765e+02, // 70 2534 6.734672e+02, 7.642575e+02, 8.673056e+02, 9.8 1549 6.734672e+02, 7.642575e+02, 8.673056e+02, 9.842662e+02, 1.117018e+03, 2535 1.267692e+03, 1.438709e+03, 1.632816e+03, 1.8 1550 1.267692e+03, 1.438709e+03, 1.632816e+03, 1.853128e+03, 2.103186e+03, // 80 2536 2.387004e+03, 2.709140e+03, 3.074768e+03, 3.4 1551 2.387004e+03, 2.709140e+03, 3.074768e+03, 3.489760e+03, 3.960780e+03, 2537 4.495394e+03, 5.102185e+03, 5.790900e+03, 6.5 1552 4.495394e+03, 5.102185e+03, 5.790900e+03, 6.572600e+03, 7.459837e+03, // 90 2538 8.466860e+03, 9.609843e+03, 1.090714e+04, 1.2 1553 8.466860e+03, 9.609843e+03, 1.090714e+04, 1.237959e+04, 1.405083e+04, 2539 1.594771e+04, 1.810069e+04, 2.054434e+04, 2.3 1554 1.594771e+04, 1.810069e+04, 2.054434e+04, 2.331792e+04, 2.646595e+04, // 100 2540 3.003901e+04, 3.409446e+04, 3.869745e+04, 4.3 1555 3.003901e+04, 3.409446e+04, 3.869745e+04, 4.392189e+04, 4.985168e+04, 2541 5.658206e+04, 6.422112e+04, 7.289153e+04, 8.2 1556 5.658206e+04, 6.422112e+04, 7.289153e+04, 8.273254e+04, 9.390219e+04, // 110 2542 1.065799e+05 1557 1.065799e+05 2543 }; << 1558 } ; 2544 1559 2545 ///////////////////////////////////////////// 1560 /////////////////////////////////////////////////////////////////////// 2546 // 1561 // 2547 // The number of gamma for creation of splin 1562 // The number of gamma for creation of spline (near ion-min , G ~ 4 ) 2548 // 1563 // 2549 1564 2550 const 1565 const 2551 G4int G4PAIxSection::fRefGammaNumber = 29; << 1566 G4int G4PAIxSection::fRefGammaNumber = 29 ; 2552 1567 2553 1568 2554 // 1569 // 2555 // end of G4PAIxSection implementation file 1570 // end of G4PAIxSection implementation file 2556 // 1571 // 2557 ///////////////////////////////////////////// 1572 //////////////////////////////////////////////////////////////////////////// 2558 1573 2559 1574