| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4EnergyLossTables.cc,v 1.27 2003/04/18 17:49:26 vnivanch Exp $
>> 25 // GEANT4 tag $Name: geant4-05-02-patch-01 $
27 // 26 //
28 // ------------------------------------------- 27 // -------------------------------------------------------------------
29 // first version created by P.Urban , 06/04/19 28 // first version created by P.Urban , 06/04/1998
30 // modifications + "precise" functions added b 29 // modifications + "precise" functions added by L.Urban , 27/05/98
31 // modifications , TOF functions , 26/10/98, L 30 // modifications , TOF functions , 26/10/98, L.Urban
32 // cache mechanism in order to gain time, 11/0 31 // cache mechanism in order to gain time, 11/02/99, L.Urban
33 // bug fixed , 12/04/99 , L.Urban 32 // bug fixed , 12/04/99 , L.Urban
34 // 10.11.99: moved from RWT hash dictionary to 33 // 10.11.99: moved from RWT hash dictionary to STL map, G.Barrand, M.Maire
35 // 27.09.01 L.Urban , bug fixed (negative ener 34 // 27.09.01 L.Urban , bug fixed (negative energy deposit)
36 // 26.10.01 all static functions moved from .i 35 // 26.10.01 all static functions moved from .icc files (mma)
37 // 15.01.03 Add interfaces required for "cut p 36 // 15.01.03 Add interfaces required for "cut per region" (V.Ivanchenko)
38 // 12.03.03 Add warnings to obsolete interface 37 // 12.03.03 Add warnings to obsolete interfaces (V.Ivanchenko)
39 // 10.04.03 Add call to G4LossTableManager is 38 // 10.04.03 Add call to G4LossTableManager is particle is not registered (V.Ivanchenko)
40 // 39 //
41 // ------------------------------------------- 40 // -------------------------------------------------------------------
42 41
43 #include "G4EnergyLossTables.hh" 42 #include "G4EnergyLossTables.hh"
44 #include "G4SystemOfUnits.hh" <<
45 #include "G4MaterialCutsCouple.hh" 43 #include "G4MaterialCutsCouple.hh"
46 #include "G4RegionStore.hh" 44 #include "G4RegionStore.hh"
47 #include "G4LossTableManager.hh" 45 #include "G4LossTableManager.hh"
48 46
49 47
50 //....oooOO0OOooo........oooOO0OOooo........oo 48 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
51 49
52 G4EnergyLossTablesHelper *G4EnergyLossTables:: << 50 G4EnergyLossTablesHelper G4EnergyLossTables::t ;
53 G4EnergyLossTablesHelper *G4EnergyLossTables:: << 51 G4EnergyLossTablesHelper G4EnergyLossTables::null_loss ;
54 G4ParticleDefinition* G4EnergyLossTables::last << 52 const G4ParticleDefinition* G4EnergyLossTables::lastParticle = 0;
55 G4double G4EnergyLossTables::QQPositron = 1.0; << 53 G4double G4EnergyLossTables::QQPositron = eplus*eplus ;
56 G4double G4EnergyLossTables::Chargesquare ; 54 G4double G4EnergyLossTables::Chargesquare ;
57 G4int G4EnergyLossTables::oldIndex = -1 ; 55 G4int G4EnergyLossTables::oldIndex = -1 ;
58 G4double G4EnergyLossTables::rmin = 0. ; 56 G4double G4EnergyLossTables::rmin = 0. ;
59 G4double G4EnergyLossTables::rmax = 0. ; 57 G4double G4EnergyLossTables::rmax = 0. ;
60 G4double G4EnergyLossTables::Thigh = 0. ; 58 G4double G4EnergyLossTables::Thigh = 0. ;
61 G4int G4EnergyLossTables::let_counter = 0; 59 G4int G4EnergyLossTables::let_counter = 0;
62 G4int G4EnergyLossTables::let_max_num_warni << 60 G4int G4EnergyLossTables::let_max_num_warnings = 2;
63 G4bool G4EnergyLossTables::first_loss = true 61 G4bool G4EnergyLossTables::first_loss = true;
64 62
65 G4EnergyLossTables::helper_map *G4EnergyLossTa << 63 G4EnergyLossTables::helper_map G4EnergyLossTables::dict;
66 64
67 //....oooOO0OOooo........oooOO0OOooo........oo 65 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
68 66
69 G4EnergyLossTablesHelper::G4EnergyLossTablesHe 67 G4EnergyLossTablesHelper::G4EnergyLossTablesHelper(
70 const G4PhysicsTable* aDEDXTable, 68 const G4PhysicsTable* aDEDXTable,
71 const G4PhysicsTable* aRangeTable, 69 const G4PhysicsTable* aRangeTable,
72 const G4PhysicsTable* anInverseRangeTable, 70 const G4PhysicsTable* anInverseRangeTable,
73 const G4PhysicsTable* aLabTimeTable, 71 const G4PhysicsTable* aLabTimeTable,
74 const G4PhysicsTable* aProperTimeTable, 72 const G4PhysicsTable* aProperTimeTable,
75 G4double aLowestKineticEnergy, 73 G4double aLowestKineticEnergy,
76 G4double aHighestKineticEnergy, 74 G4double aHighestKineticEnergy,
77 G4double aMassRatio, 75 G4double aMassRatio,
78 G4int aNumberOfBins) 76 G4int aNumberOfBins)
79 : 77 :
80 theDEDXTable(aDEDXTable), theRangeTable(aRan 78 theDEDXTable(aDEDXTable), theRangeTable(aRangeTable),
81 theInverseRangeTable(anInverseRangeTable), 79 theInverseRangeTable(anInverseRangeTable),
82 theLabTimeTable(aLabTimeTable), 80 theLabTimeTable(aLabTimeTable),
83 theProperTimeTable(aProperTimeTable), 81 theProperTimeTable(aProperTimeTable),
84 theLowestKineticEnergy(aLowestKineticEnergy) 82 theLowestKineticEnergy(aLowestKineticEnergy),
85 theHighestKineticEnergy(aHighestKineticEnerg 83 theHighestKineticEnergy(aHighestKineticEnergy),
86 theMassRatio(aMassRatio), 84 theMassRatio(aMassRatio),
87 theNumberOfBins(aNumberOfBins) 85 theNumberOfBins(aNumberOfBins)
88 { } 86 { }
89 87
90 //....oooOO0OOooo........oooOO0OOooo........oo 88 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
91 89
92 G4EnergyLossTablesHelper::G4EnergyLossTablesHe 90 G4EnergyLossTablesHelper::G4EnergyLossTablesHelper()
93 { << 91 { }
94 theLowestKineticEnergy = 0.0; <<
95 theHighestKineticEnergy= 0.0; <<
96 theMassRatio = 0.0; <<
97 theNumberOfBins = 0; <<
98 theDEDXTable = theRangeTable = theInverseRan <<
99 = theProperTimeTable = nullptr; <<
100 } <<
101 92
102 //....oooOO0OOooo........oooOO0OOooo........oo 93 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
103 94
104 void G4EnergyLossTables::Register( 95 void G4EnergyLossTables::Register(
105 const G4ParticleDefinition* p, 96 const G4ParticleDefinition* p,
106 const G4PhysicsTable* tDEDX, 97 const G4PhysicsTable* tDEDX,
107 const G4PhysicsTable* tRange, 98 const G4PhysicsTable* tRange,
108 const G4PhysicsTable* tInverseRange, 99 const G4PhysicsTable* tInverseRange,
109 const G4PhysicsTable* tLabTime, 100 const G4PhysicsTable* tLabTime,
110 const G4PhysicsTable* tProperTime, 101 const G4PhysicsTable* tProperTime,
111 G4double lowestKineticEnergy, 102 G4double lowestKineticEnergy,
112 G4double highestKineticEnergy, 103 G4double highestKineticEnergy,
113 G4double massRatio, 104 G4double massRatio,
114 G4int NumberOfBins) 105 G4int NumberOfBins)
115 { 106 {
116 if (!dict) dict = new G4EnergyLossTables::he << 107 dict[p]= G4EnergyLossTablesHelper(tDEDX, tRange,tInverseRange,
117 if (!null_loss) null_loss = new G4EnergyLoss <<
118 if (!t) t = new G4EnergyLossTablesHelper; <<
119 <<
120 (*dict)[p]= G4EnergyLossTablesHelper(tDEDX, <<
121 tLabTime,tProperTime,lowes 108 tLabTime,tProperTime,lowestKineticEnergy,
122 highestKineticEnergy, massRatio,Number 109 highestKineticEnergy, massRatio,NumberOfBins);
123 110
124 *t = GetTables(p) ; // important for cach << 111 t = GetTables(p) ; // important for cache !!!!!
125 lastParticle = (G4ParticleDefinition*) p ; << 112 lastParticle = p ;
126 Chargesquare = (p->GetPDGCharge())*(p->GetPD 113 Chargesquare = (p->GetPDGCharge())*(p->GetPDGCharge())/
127 QQPositron ; 114 QQPositron ;
128 if (first_loss ) { 115 if (first_loss ) {
129 *null_loss = G4EnergyLossTablesHelper( << 116 null_loss = G4EnergyLossTablesHelper(0, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0);
130 nullptr, nullptr, nullptr, nu <<
131 first_loss = false; 117 first_loss = false;
132 } 118 }
133 } 119 }
134 120
135 //....oooOO0OOooo........oooOO0OOooo........oo 121 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
136 122
137 const G4PhysicsTable* G4EnergyLossTables::GetD 123 const G4PhysicsTable* G4EnergyLossTables::GetDEDXTable(
138 const G4ParticleDefinition* p) 124 const G4ParticleDefinition* p)
139 { 125 {
140 if (!dict) dict = new G4EnergyLossTables::he <<
141 helper_map::iterator it; 126 helper_map::iterator it;
142 if((it=dict->find(p))==dict->end()) return n << 127 if((it=dict.find(p))==dict.end()) return 0;
143 return (*it).second.theDEDXTable; 128 return (*it).second.theDEDXTable;
144 } 129 }
145 130
146 //....oooOO0OOooo........oooOO0OOooo........oo 131 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
147 132
148 const G4PhysicsTable* G4EnergyLossTables::GetR 133 const G4PhysicsTable* G4EnergyLossTables::GetRangeTable(
149 const G4ParticleDefinition* p) 134 const G4ParticleDefinition* p)
150 { 135 {
151 if (!dict) dict = new G4EnergyLossTables::he <<
152 helper_map::iterator it; 136 helper_map::iterator it;
153 if((it=dict->find(p))==dict->end()) return n << 137 if((it=dict.find(p))==dict.end()) return 0;
154 return (*it).second.theRangeTable; 138 return (*it).second.theRangeTable;
155 } 139 }
156 140
157 //....oooOO0OOooo........oooOO0OOooo........oo 141 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
158 142
159 const G4PhysicsTable* G4EnergyLossTables::GetI 143 const G4PhysicsTable* G4EnergyLossTables::GetInverseRangeTable(
160 const G4ParticleDefinition* p) 144 const G4ParticleDefinition* p)
161 { 145 {
162 if (!dict) dict = new G4EnergyLossTables::he <<
163 helper_map::iterator it; 146 helper_map::iterator it;
164 if((it=dict->find(p))==dict->end()) return n << 147 if((it=dict.find(p))==dict.end()) return 0;
165 return (*it).second.theInverseRangeTable; 148 return (*it).second.theInverseRangeTable;
166 } 149 }
167 150
168 //....oooOO0OOooo........oooOO0OOooo........oo 151 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
169 152
170 const G4PhysicsTable* G4EnergyLossTables::GetL 153 const G4PhysicsTable* G4EnergyLossTables::GetLabTimeTable(
171 const G4ParticleDefinition* p) 154 const G4ParticleDefinition* p)
172 { 155 {
173 if (!dict) dict = new G4EnergyLossTables::he <<
174 helper_map::iterator it; 156 helper_map::iterator it;
175 if((it=dict->find(p))==dict->end()) return n << 157 if((it=dict.find(p))==dict.end()) return 0;
176 return (*it).second.theLabTimeTable; 158 return (*it).second.theLabTimeTable;
177 } 159 }
178 160
179 //....oooOO0OOooo........oooOO0OOooo........oo 161 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
180 162
181 const G4PhysicsTable* G4EnergyLossTables::GetP 163 const G4PhysicsTable* G4EnergyLossTables::GetProperTimeTable(
182 const G4ParticleDefinition* p) 164 const G4ParticleDefinition* p)
183 { 165 {
184 if (!dict) dict = new G4EnergyLossTables::he <<
185 helper_map::iterator it; 166 helper_map::iterator it;
186 if((it=dict->find(p))==dict->end()) return n << 167 if((it=dict.find(p))==dict.end()) return 0;
187 return (*it).second.theProperTimeTable; 168 return (*it).second.theProperTimeTable;
188 } 169 }
189 170
190 //....oooOO0OOooo........oooOO0OOooo........oo 171 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
191 172
192 G4EnergyLossTablesHelper G4EnergyLossTables::G 173 G4EnergyLossTablesHelper G4EnergyLossTables::GetTables(
193 const G4ParticleDefinition* p) 174 const G4ParticleDefinition* p)
194 { 175 {
195 if (!dict) dict = new G4EnergyLossTables::he <<
196 if (!null_loss) null_loss = new G4EnergyLoss <<
197 <<
198 helper_map::iterator it; 176 helper_map::iterator it;
199 if ((it=dict->find(p))==dict->end()) { << 177 if ((it=dict.find(p))==dict.end()) {
200 return *null_loss; << 178 // G4cout << "Table is not found out for " << p->GetParticleName() << G4endl;
>> 179 // G4Exception("G4EnergyLossTables::GetTables: table not found!");
>> 180 // exit(1);
>> 181 return null_loss;
201 } 182 }
202 return (*it).second; 183 return (*it).second;
203 } 184 }
204 185
205 //....oooOO0OOooo........oooOO0OOooo........oo 186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
206 187
207 G4double G4EnergyLossTables::GetDEDX( 188 G4double G4EnergyLossTables::GetDEDX(
208 const G4ParticleDefinition *aParticle, 189 const G4ParticleDefinition *aParticle,
209 G4double KineticEnergy, 190 G4double KineticEnergy,
210 const G4Material *aMaterial) 191 const G4Material *aMaterial)
211 { 192 {
212 if (!t) t = new G4EnergyLossTablesHelper; <<
213 <<
214 CPRWarning(); 193 CPRWarning();
215 if(aParticle != (const G4ParticleDefinition* << 194 if(aParticle != lastParticle)
216 { 195 {
217 *t= GetTables(aParticle); << 196 t= GetTables(aParticle);
218 lastParticle = (G4ParticleDefinition*) aPa << 197 lastParticle = aParticle ;
219 Chargesquare = (aParticle->GetPDGCharge()) 198 Chargesquare = (aParticle->GetPDGCharge())*
220 (aParticle->GetPDGCharge()) 199 (aParticle->GetPDGCharge())/
221 QQPositron ; 200 QQPositron ;
222 oldIndex = -1 ; 201 oldIndex = -1 ;
223 } 202 }
224 const G4PhysicsTable* dEdxTable= t->theDEDX << 203 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
225 if (!dEdxTable) { << 204 if (!dEdxTable) ParticleHaveNoLoss(aParticle);
226 ParticleHaveNoLoss(aParticle,"dEdx"); <<
227 return 0.0; <<
228 } <<
229 205
230 G4int materialIndex = (G4int)aMaterial->GetI << 206 G4int materialIndex = aMaterial->GetIndex();
231 G4double scaledKineticEnergy = KineticEnergy << 207 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
232 G4double dEdx; 208 G4double dEdx;
233 G4bool isOut; 209 G4bool isOut;
234 210
235 if (scaledKineticEnergy<t->theLowestKineticE << 211 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
236 212
237 dEdx =(*dEdxTable)(materialIndex)->GetVal 213 dEdx =(*dEdxTable)(materialIndex)->GetValue(
238 t->theLowestKineticEnergy,isOut) << 214 t.theLowestKineticEnergy,isOut)
239 *std::sqrt(scaledKineticEnergy/t->t << 215 *sqrt(scaledKineticEnergy/t.theLowestKineticEnergy);
240 216
241 } else if (scaledKineticEnergy>t->theHighest << 217 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
242 218
243 dEdx = (*dEdxTable)(materialIndex)->GetVa 219 dEdx = (*dEdxTable)(materialIndex)->GetValue(
244 t->theHighestKineticEnergy,isOut); << 220 t.theHighestKineticEnergy,isOut);
245 221
246 } else { 222 } else {
247 223
248 dEdx = (*dEdxTable)(materialIndex)->GetVal 224 dEdx = (*dEdxTable)(materialIndex)->GetValue(
249 scaledKineticEnergy,isOut); 225 scaledKineticEnergy,isOut);
250 226
251 } 227 }
252 228
253 return dEdx*Chargesquare; 229 return dEdx*Chargesquare;
254 } 230 }
255 231
256 //....oooOO0OOooo........oooOO0OOooo........oo 232 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
257 233
258 G4double G4EnergyLossTables::GetLabTime( 234 G4double G4EnergyLossTables::GetLabTime(
259 const G4ParticleDefinition *aParticle, 235 const G4ParticleDefinition *aParticle,
260 G4double KineticEnergy, 236 G4double KineticEnergy,
261 const G4Material *aMaterial) 237 const G4Material *aMaterial)
262 { 238 {
263 if (!t) t = new G4EnergyLossTablesHelper; <<
264 <<
265 CPRWarning(); 239 CPRWarning();
266 if(aParticle != (const G4ParticleDefinition* << 240 if(aParticle != lastParticle)
267 { 241 {
268 *t= GetTables(aParticle); << 242 t= GetTables(aParticle);
269 lastParticle = (G4ParticleDefinition*) aPa << 243 lastParticle = aParticle ;
270 oldIndex = -1 ; 244 oldIndex = -1 ;
271 } 245 }
272 const G4PhysicsTable* labtimeTable= t->theLa << 246 const G4PhysicsTable* labtimeTable= t.theLabTimeTable;
273 if (!labtimeTable) { << 247 if (!labtimeTable) ParticleHaveNoLoss(aParticle);
274 ParticleHaveNoLoss(aParticle,"LabTime"); <<
275 return 0.0; <<
276 } <<
277 248
278 const G4double parlowen=0.4 , ppar=0.5-parlo 249 const G4double parlowen=0.4 , ppar=0.5-parlowen ;
279 G4int materialIndex = (G4int)aMaterial->GetI << 250 G4int materialIndex = aMaterial->GetIndex();
280 G4double scaledKineticEnergy = KineticEnergy << 251 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
281 G4double time; 252 G4double time;
282 G4bool isOut; 253 G4bool isOut;
283 254
284 if (scaledKineticEnergy<t->theLowestKineticE << 255 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
285 256
286 time = std::exp(ppar*std::log(scaledKinet << 257 time = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
287 (*labtimeTable)(materialIndex)->Ge 258 (*labtimeTable)(materialIndex)->GetValue(
288 t->theLowestKineticEnergy,isOut) << 259 t.theLowestKineticEnergy,isOut);
289 260
290 261
291 } else if (scaledKineticEnergy>t->theHighest << 262 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
292 263
293 time = (*labtimeTable)(materialIndex)->Ge 264 time = (*labtimeTable)(materialIndex)->GetValue(
294 t->theHighestKineticEnergy,isOut << 265 t.theHighestKineticEnergy,isOut);
295 266
296 } else { 267 } else {
297 268
298 time = (*labtimeTable)(materialIndex)->Get 269 time = (*labtimeTable)(materialIndex)->GetValue(
299 scaledKineticEnergy,isOut); 270 scaledKineticEnergy,isOut);
300 271
301 } 272 }
302 273
303 return time/t->theMassRatio ; << 274 return time/t.theMassRatio ;
304 } 275 }
305 276
306 //....oooOO0OOooo........oooOO0OOooo........oo 277 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
307 278
308 G4double G4EnergyLossTables::GetDeltaLabTime( 279 G4double G4EnergyLossTables::GetDeltaLabTime(
309 const G4ParticleDefinition *aParticle, 280 const G4ParticleDefinition *aParticle,
310 G4double KineticEnergyStart, 281 G4double KineticEnergyStart,
311 G4double KineticEnergyEnd, 282 G4double KineticEnergyEnd,
312 const G4Material *aMaterial) 283 const G4Material *aMaterial)
313 { 284 {
314 if (!t) t = new G4EnergyLossTablesHelper; <<
315 <<
316 CPRWarning(); 285 CPRWarning();
317 if(aParticle != (const G4ParticleDefinition* << 286 if(aParticle != lastParticle)
318 { 287 {
319 *t= GetTables(aParticle); << 288 t= GetTables(aParticle);
320 lastParticle = (G4ParticleDefinition*) aPa << 289 lastParticle = aParticle ;
321 oldIndex = -1 ; 290 oldIndex = -1 ;
322 } 291 }
323 const G4PhysicsTable* labtimeTable= t->theLa << 292 const G4PhysicsTable* labtimeTable= t.theLabTimeTable;
324 if (!labtimeTable) { << 293 if (!labtimeTable) ParticleHaveNoLoss(aParticle);
325 ParticleHaveNoLoss(aParticle,"LabTime"); <<
326 return 0.0; <<
327 } <<
328 294
329 const G4double parlowen=0.4 , ppar=0.5-parlo 295 const G4double parlowen=0.4 , ppar=0.5-parlowen ;
330 const G4double dToverT = 0.05 , facT = 1. -d 296 const G4double dToverT = 0.05 , facT = 1. -dToverT ;
331 G4double timestart,timeend,deltatime,dTT; 297 G4double timestart,timeend,deltatime,dTT;
332 G4bool isOut; 298 G4bool isOut;
333 299
334 G4int materialIndex = (G4int)aMaterial->GetI << 300 G4int materialIndex = aMaterial->GetIndex();
335 G4double scaledKineticEnergy = KineticEnergy << 301 G4double scaledKineticEnergy = KineticEnergyStart*t.theMassRatio;
336 302
337 if (scaledKineticEnergy<t->theLowestKineticE << 303 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
338 304
339 timestart = std::exp(ppar*std::log(scaled << 305 timestart = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
340 (*labtimeTable)(materialIndex) 306 (*labtimeTable)(materialIndex)->GetValue(
341 t->theLowestKineticEnergy,isOu << 307 t.theLowestKineticEnergy,isOut);
342 308
343 309
344 } else if (scaledKineticEnergy>t->theHighest << 310 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
345 311
346 timestart = (*labtimeTable)(materialIndex 312 timestart = (*labtimeTable)(materialIndex)->GetValue(
347 t->theHighestKineticEnergy,isO << 313 t.theHighestKineticEnergy,isOut);
348 314
349 } else { 315 } else {
350 316
351 timestart = (*labtimeTable)(materialIndex) 317 timestart = (*labtimeTable)(materialIndex)->GetValue(
352 scaledKineticEnergy,isOut); 318 scaledKineticEnergy,isOut);
353 319
354 } 320 }
355 321
356 dTT = (KineticEnergyStart - KineticEnergyEnd 322 dTT = (KineticEnergyStart - KineticEnergyEnd)/KineticEnergyStart ;
357 323
358 if( dTT < dToverT ) 324 if( dTT < dToverT )
359 scaledKineticEnergy = facT*KineticEnergySt << 325 scaledKineticEnergy = facT*KineticEnergyStart*t.theMassRatio;
360 else 326 else
361 scaledKineticEnergy = KineticEnergyEnd*t-> << 327 scaledKineticEnergy = KineticEnergyEnd*t.theMassRatio;
362 328
363 if (scaledKineticEnergy<t->theLowestKineticE << 329 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
364 330
365 timeend = std::exp(ppar*std::log(scaledKi << 331 timeend = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
366 (*labtimeTable)(materialIndex) 332 (*labtimeTable)(materialIndex)->GetValue(
367 t->theLowestKineticEnergy,isOu << 333 t.theLowestKineticEnergy,isOut);
368 334
369 335
370 } else if (scaledKineticEnergy>t->theHighest << 336 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
371 337
372 timeend = (*labtimeTable)(materialIndex)- 338 timeend = (*labtimeTable)(materialIndex)->GetValue(
373 t->theHighestKineticEnergy,isO << 339 t.theHighestKineticEnergy,isOut);
374 340
375 } else { 341 } else {
376 342
377 timeend = (*labtimeTable)(materialIndex)-> 343 timeend = (*labtimeTable)(materialIndex)->GetValue(
378 scaledKineticEnergy,isOut); 344 scaledKineticEnergy,isOut);
379 345
380 } 346 }
381 347
382 deltatime = timestart - timeend ; 348 deltatime = timestart - timeend ;
383 349
384 if( dTT < dToverT ) 350 if( dTT < dToverT )
385 deltatime *= dTT/dToverT; 351 deltatime *= dTT/dToverT;
386 352
387 return deltatime/t->theMassRatio ; << 353 return deltatime/t.theMassRatio ;
388 } 354 }
389 355
390 //....oooOO0OOooo........oooOO0OOooo........oo 356 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
391 357
392 G4double G4EnergyLossTables::GetProperTime( 358 G4double G4EnergyLossTables::GetProperTime(
393 const G4ParticleDefinition *aParticle, 359 const G4ParticleDefinition *aParticle,
394 G4double KineticEnergy, 360 G4double KineticEnergy,
395 const G4Material *aMaterial) 361 const G4Material *aMaterial)
396 { 362 {
397 if (!t) t = new G4EnergyLossTablesHelper; <<
398 <<
399 CPRWarning(); 363 CPRWarning();
400 if(aParticle != (const G4ParticleDefinition* << 364 if(aParticle != lastParticle)
401 { 365 {
402 *t= GetTables(aParticle); << 366 t= GetTables(aParticle);
403 lastParticle = (G4ParticleDefinition*) aPa << 367 lastParticle = aParticle ;
404 oldIndex = -1 ; 368 oldIndex = -1 ;
405 } 369 }
406 const G4PhysicsTable* propertimeTable= t->th << 370 const G4PhysicsTable* propertimeTable= t.theProperTimeTable;
407 if (!propertimeTable) { << 371 if (!propertimeTable) ParticleHaveNoLoss(aParticle);
408 ParticleHaveNoLoss(aParticle,"ProperTime") <<
409 return 0.0; <<
410 } <<
411 372
412 const G4double parlowen=0.4 , ppar=0.5-parlo 373 const G4double parlowen=0.4 , ppar=0.5-parlowen ;
413 G4int materialIndex = (G4int)aMaterial->GetI << 374 G4int materialIndex = aMaterial->GetIndex();
414 G4double scaledKineticEnergy = KineticEnergy << 375 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
415 G4double time; 376 G4double time;
416 G4bool isOut; 377 G4bool isOut;
417 378
418 if (scaledKineticEnergy<t->theLowestKineticE << 379 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
419 380
420 time = std::exp(ppar*std::log(scaledKinet << 381 time = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
421 (*propertimeTable)(materialIndex)- 382 (*propertimeTable)(materialIndex)->GetValue(
422 t->theLowestKineticEnergy,isOut) << 383 t.theLowestKineticEnergy,isOut);
423 384
424 385
425 } else if (scaledKineticEnergy>t->theHighest << 386 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
426 387
427 time = (*propertimeTable)(materialIndex)- 388 time = (*propertimeTable)(materialIndex)->GetValue(
428 t->theHighestKineticEnergy,isOut << 389 t.theHighestKineticEnergy,isOut);
429 390
430 } else { 391 } else {
431 << 392
432 time = (*propertimeTable)(materialIndex)-> 393 time = (*propertimeTable)(materialIndex)->GetValue(
433 scaledKineticEnergy,isOut); 394 scaledKineticEnergy,isOut);
434 395
435 } 396 }
436 397
437 return time/t->theMassRatio ; << 398 return time/t.theMassRatio ;
438 } 399 }
439 400
440 //....oooOO0OOooo........oooOO0OOooo........oo 401 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
441 402
442 G4double G4EnergyLossTables::GetDeltaProperTim 403 G4double G4EnergyLossTables::GetDeltaProperTime(
443 const G4ParticleDefinition *aParticle, 404 const G4ParticleDefinition *aParticle,
444 G4double KineticEnergyStart, 405 G4double KineticEnergyStart,
445 G4double KineticEnergyEnd, 406 G4double KineticEnergyEnd,
446 const G4Material *aMaterial) 407 const G4Material *aMaterial)
447 { 408 {
448 if (!t) t = new G4EnergyLossTablesHelper; <<
449 <<
450 CPRWarning(); 409 CPRWarning();
451 if(aParticle != (const G4ParticleDefinition* << 410 if(aParticle != lastParticle)
452 { 411 {
453 *t= GetTables(aParticle); << 412 t= GetTables(aParticle);
454 lastParticle = (G4ParticleDefinition*) aPa << 413 lastParticle = aParticle ;
455 oldIndex = -1 ; 414 oldIndex = -1 ;
456 } 415 }
457 const G4PhysicsTable* propertimeTable= t->th << 416 const G4PhysicsTable* propertimeTable= t.theProperTimeTable;
458 if (!propertimeTable) { << 417 if (!propertimeTable) ParticleHaveNoLoss(aParticle);
459 ParticleHaveNoLoss(aParticle,"ProperTime") <<
460 return 0.0; <<
461 } <<
462 418
463 const G4double parlowen=0.4 , ppar=0.5-parlo 419 const G4double parlowen=0.4 , ppar=0.5-parlowen ;
464 const G4double dToverT = 0.05 , facT = 1. -d 420 const G4double dToverT = 0.05 , facT = 1. -dToverT ;
465 G4double timestart,timeend,deltatime,dTT; 421 G4double timestart,timeend,deltatime,dTT;
466 G4bool isOut; 422 G4bool isOut;
467 423
468 G4int materialIndex = (G4int)aMaterial->GetI << 424 G4int materialIndex = aMaterial->GetIndex();
469 G4double scaledKineticEnergy = KineticEnergy << 425 G4double scaledKineticEnergy = KineticEnergyStart*t.theMassRatio;
470 426
471 if (scaledKineticEnergy<t->theLowestKineticE << 427 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
472 428
473 timestart = std::exp(ppar*std::log(scaled << 429 timestart = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
474 (*propertimeTable)(materialInd 430 (*propertimeTable)(materialIndex)->GetValue(
475 t->theLowestKineticEnergy,isOu << 431 t.theLowestKineticEnergy,isOut);
476 432
477 433
478 } else if (scaledKineticEnergy>t->theHighest << 434 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
479 435
480 timestart = (*propertimeTable)(materialIn 436 timestart = (*propertimeTable)(materialIndex)->GetValue(
481 t->theHighestKineticEnergy,isO << 437 t.theHighestKineticEnergy,isOut);
482 438
483 } else { 439 } else {
484 440
485 timestart = (*propertimeTable)(materialInd 441 timestart = (*propertimeTable)(materialIndex)->GetValue(
486 scaledKineticEnergy,isOut); 442 scaledKineticEnergy,isOut);
487 443
488 } 444 }
489 445
490 dTT = (KineticEnergyStart - KineticEnergyEnd 446 dTT = (KineticEnergyStart - KineticEnergyEnd)/KineticEnergyStart ;
491 447
492 if( dTT < dToverT ) 448 if( dTT < dToverT )
493 scaledKineticEnergy = facT*KineticEnergySt << 449 scaledKineticEnergy = facT*KineticEnergyStart*t.theMassRatio;
494 else 450 else
495 scaledKineticEnergy = KineticEnergyEnd*t-> << 451 scaledKineticEnergy = KineticEnergyEnd*t.theMassRatio;
496 452
497 if (scaledKineticEnergy<t->theLowestKineticE << 453 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
498 454
499 timeend = std::exp(ppar*std::log(scaledKi << 455 timeend = exp(ppar*log(scaledKineticEnergy/t.theLowestKineticEnergy))*
500 (*propertimeTable)(materialInd 456 (*propertimeTable)(materialIndex)->GetValue(
501 t->theLowestKineticEnergy,isOu << 457 t.theLowestKineticEnergy,isOut);
502 458
503 459
504 } else if (scaledKineticEnergy>t->theHighest << 460 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
505 461
506 timeend = (*propertimeTable)(materialInde 462 timeend = (*propertimeTable)(materialIndex)->GetValue(
507 t->theHighestKineticEnergy,isO << 463 t.theHighestKineticEnergy,isOut);
508 464
509 } else { 465 } else {
510 466
511 timeend = (*propertimeTable)(materialIndex 467 timeend = (*propertimeTable)(materialIndex)->GetValue(
512 scaledKineticEnergy,isOut); 468 scaledKineticEnergy,isOut);
513 469
514 } 470 }
515 471
516 deltatime = timestart - timeend ; 472 deltatime = timestart - timeend ;
517 473
518 if( dTT < dToverT ) 474 if( dTT < dToverT )
519 deltatime *= dTT/dToverT ; 475 deltatime *= dTT/dToverT ;
520 476
521 return deltatime/t->theMassRatio ; << 477 return deltatime/t.theMassRatio ;
522 } 478 }
523 479
524 //....oooOO0OOooo........oooOO0OOooo........oo 480 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
525 481
526 G4double G4EnergyLossTables::GetRange( 482 G4double G4EnergyLossTables::GetRange(
527 const G4ParticleDefinition *aParticle, 483 const G4ParticleDefinition *aParticle,
528 G4double KineticEnergy, 484 G4double KineticEnergy,
529 const G4Material *aMaterial) 485 const G4Material *aMaterial)
530 { 486 {
531 if (!t) t = new G4EnergyLossTablesHelper; <<
532 <<
533 CPRWarning(); 487 CPRWarning();
534 if(aParticle != (const G4ParticleDefinition* << 488 if(aParticle != lastParticle)
535 { 489 {
536 *t= GetTables(aParticle); << 490 t= GetTables(aParticle);
537 lastParticle = (G4ParticleDefinition*) aPa << 491 lastParticle = aParticle ;
538 Chargesquare = (aParticle->GetPDGCharge()) 492 Chargesquare = (aParticle->GetPDGCharge())*
539 (aParticle->GetPDGCharge()) 493 (aParticle->GetPDGCharge())/
540 QQPositron ; 494 QQPositron ;
541 oldIndex = -1 ; 495 oldIndex = -1 ;
542 } 496 }
543 const G4PhysicsTable* rangeTable= t->theRang << 497 const G4PhysicsTable* rangeTable= t.theRangeTable;
544 const G4PhysicsTable* dEdxTable= t->theDEDX << 498 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
545 if (!rangeTable) { << 499 if (!dEdxTable || !rangeTable) ParticleHaveNoLoss(aParticle);
546 ParticleHaveNoLoss(aParticle,"Range"); <<
547 return 0.0; <<
548 } <<
549 500
550 G4int materialIndex = (G4int)aMaterial->GetI << 501 G4int materialIndex = aMaterial->GetIndex();
551 G4double scaledKineticEnergy = KineticEnergy << 502 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
552 G4double Range; 503 G4double Range;
553 G4bool isOut; 504 G4bool isOut;
554 505
555 if (scaledKineticEnergy<t->theLowestKineticE << 506 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
556 507
557 Range = std::sqrt(scaledKineticEnergy/t->t << 508 Range = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)*
558 (*rangeTable)(materialIndex)->GetV 509 (*rangeTable)(materialIndex)->GetValue(
559 t->theLowestKineticEnergy,isOut) << 510 t.theLowestKineticEnergy,isOut);
560 511
561 } else if (scaledKineticEnergy>t->theHighest << 512 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
562 513
563 Range = (*rangeTable)(materialIndex)->GetV 514 Range = (*rangeTable)(materialIndex)->GetValue(
564 t->theHighestKineticEnergy,isOut)+ << 515 t.theHighestKineticEnergy,isOut)+
565 (scaledKineticEnergy-t->theHighest << 516 (scaledKineticEnergy-t.theHighestKineticEnergy)/
566 (*dEdxTable)(materialIndex)->GetVa 517 (*dEdxTable)(materialIndex)->GetValue(
567 t->theHighestKineticEnergy,isOut << 518 t.theHighestKineticEnergy,isOut);
568 519
569 } else { 520 } else {
570 521
571 Range = (*rangeTable)(materialIndex)->GetV 522 Range = (*rangeTable)(materialIndex)->GetValue(
572 scaledKineticEnergy,isOut); 523 scaledKineticEnergy,isOut);
573 524
574 } 525 }
575 526
576 return Range/(Chargesquare*t->theMassRatio); << 527 return Range/(Chargesquare*t.theMassRatio);
577 } 528 }
578 529
579 //....oooOO0OOooo........oooOO0OOooo........oo 530 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
580 531
581 G4double G4EnergyLossTables::GetPreciseEnergyF 532 G4double G4EnergyLossTables::GetPreciseEnergyFromRange(
582 const G4P 533 const G4ParticleDefinition *aParticle,
583 G4d 534 G4double range,
584 const G4M 535 const G4Material *aMaterial)
585 // it returns the value of the kinetic energy 536 // it returns the value of the kinetic energy for a given range
586 { 537 {
587 if (!t) t = new G4EnergyLossTablesHelper; <<
588 <<
589 CPRWarning(); 538 CPRWarning();
590 if( aParticle != (const G4ParticleDefinition << 539 if( aParticle != lastParticle)
591 { 540 {
592 *t= GetTables(aParticle); << 541 t= GetTables(aParticle);
593 lastParticle = (G4ParticleDefinition*) aPa << 542 lastParticle = aParticle;
594 Chargesquare = (aParticle->GetPDGCharge()) 543 Chargesquare = (aParticle->GetPDGCharge())*
595 (aParticle->GetPDGCharge()) 544 (aParticle->GetPDGCharge())/
596 QQPositron ; 545 QQPositron ;
597 oldIndex = -1 ; 546 oldIndex = -1 ;
598 } 547 }
599 const G4PhysicsTable* dEdxTable= t->theDEDX << 548 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
600 const G4PhysicsTable* inverseRangeTable= t- << 549 const G4PhysicsTable* inverseRangeTable= t.theInverseRangeTable;
601 if (!inverseRangeTable) { << 550 if (!dEdxTable || !inverseRangeTable) ParticleHaveNoLoss(aParticle);
602 ParticleHaveNoLoss(aParticle,"InverseRange <<
603 return 0.0; <<
604 } <<
605 551
606 G4double scaledrange,scaledKineticEnergy ; 552 G4double scaledrange,scaledKineticEnergy ;
607 G4bool isOut ; 553 G4bool isOut ;
608 554
609 G4int materialIndex = (G4int)aMaterial->GetI << 555 G4int materialIndex = aMaterial->GetIndex() ;
610 556
611 if(materialIndex != oldIndex) 557 if(materialIndex != oldIndex)
612 { 558 {
613 oldIndex = materialIndex ; 559 oldIndex = materialIndex ;
614 rmin = (*inverseRangeTable)(materialIndex) 560 rmin = (*inverseRangeTable)(materialIndex)->
615 GetLowEdgeEnergy 561 GetLowEdgeEnergy(0) ;
616 rmax = (*inverseRangeTable)(materialIndex) 562 rmax = (*inverseRangeTable)(materialIndex)->
617 GetLowEdgeEnergy(t->theNumb << 563 GetLowEdgeEnergy(t.theNumberOfBins-2) ;
618 Thigh = (*inverseRangeTable)(materialIndex 564 Thigh = (*inverseRangeTable)(materialIndex)->
619 GetValue(rmax,is 565 GetValue(rmax,isOut) ;
620 } 566 }
621 567
622 scaledrange = range*Chargesquare*t->theMassR << 568 scaledrange = range*Chargesquare*t.theMassRatio ;
623 569
624 if(scaledrange < rmin) 570 if(scaledrange < rmin)
625 { 571 {
626 scaledKineticEnergy = t->theLowestKineticE << 572 scaledKineticEnergy = t.theLowestKineticEnergy*
627 scaledrange*scaledrange/(rm 573 scaledrange*scaledrange/(rmin*rmin) ;
628 } 574 }
629 else 575 else
630 { 576 {
631 if(scaledrange < rmax) 577 if(scaledrange < rmax)
632 { 578 {
633 scaledKineticEnergy = (*inverseRangeTabl 579 scaledKineticEnergy = (*inverseRangeTable)(materialIndex)->
634 GetValue( scaled 580 GetValue( scaledrange,isOut) ;
635 } 581 }
636 else 582 else
637 { 583 {
638 scaledKineticEnergy = Thigh + 584 scaledKineticEnergy = Thigh +
639 (scaledrange-rmax)* 585 (scaledrange-rmax)*
640 (*dEdxTable)(materialInd 586 (*dEdxTable)(materialIndex)->
641 GetValue(Thig 587 GetValue(Thigh,isOut) ;
642 } 588 }
643 } 589 }
644 590
645 return scaledKineticEnergy/t->theMassRatio ; << 591 return scaledKineticEnergy/t.theMassRatio ;
646 } 592 }
647 593
648 //....oooOO0OOooo........oooOO0OOooo........oo 594 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
649 595
650 G4double G4EnergyLossTables::GetPreciseDEDX( 596 G4double G4EnergyLossTables::GetPreciseDEDX(
651 const G4ParticleDefinition *aParticle, 597 const G4ParticleDefinition *aParticle,
652 G4double KineticEnergy, 598 G4double KineticEnergy,
653 const G4Material *aMaterial) 599 const G4Material *aMaterial)
654 { 600 {
655 if (!t) t = new G4EnergyLossTablesHelper; <<
656 <<
657 CPRWarning(); 601 CPRWarning();
658 if( aParticle != (const G4ParticleDefinition << 602 if( aParticle != lastParticle)
659 { 603 {
660 *t= GetTables(aParticle); << 604 t= GetTables(aParticle);
661 lastParticle = (G4ParticleDefinition*) aPa << 605 lastParticle = aParticle;
662 Chargesquare = (aParticle->GetPDGCharge()) 606 Chargesquare = (aParticle->GetPDGCharge())*
663 (aParticle->GetPDGCharge()) 607 (aParticle->GetPDGCharge())/
664 QQPositron ; 608 QQPositron ;
665 oldIndex = -1 ; 609 oldIndex = -1 ;
666 } 610 }
667 const G4PhysicsTable* dEdxTable= t->theDEDX << 611 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
668 if (!dEdxTable) { << 612 if (!dEdxTable) ParticleHaveNoLoss(aParticle);
669 ParticleHaveNoLoss(aParticle,"dEdx"); <<
670 return 0.0; <<
671 } <<
672 613
673 G4int materialIndex = (G4int)aMaterial->GetI << 614 G4int materialIndex = aMaterial->GetIndex();
674 G4double scaledKineticEnergy = KineticEnergy << 615 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
675 G4double dEdx; 616 G4double dEdx;
676 G4bool isOut; 617 G4bool isOut;
677 618
678 if (scaledKineticEnergy<t->theLowestKineticE << 619 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
679 620
680 dEdx = std::sqrt(scaledKineticEnergy/t->t << 621 dEdx = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)
681 *(*dEdxTable)(materialIndex)->GetV 622 *(*dEdxTable)(materialIndex)->GetValue(
682 t->theLowestKineticEnergy,isOut) << 623 t.theLowestKineticEnergy,isOut);
683 624
684 } else if (scaledKineticEnergy>t->theHighest << 625 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
685 626
686 dEdx = (*dEdxTable)(materialIndex)->GetVa 627 dEdx = (*dEdxTable)(materialIndex)->GetValue(
687 t->theHighestKineticEnergy,isOut); << 628 t.theHighestKineticEnergy,isOut);
688 629
689 } else { 630 } else {
690 631
691 dEdx = (*dEdxTable)(materialIndex)->GetV 632 dEdx = (*dEdxTable)(materialIndex)->GetValue(
692 scaledKineticEnergy, 633 scaledKineticEnergy,isOut) ;
693 634
694 } 635 }
695 636
696 return dEdx*Chargesquare; 637 return dEdx*Chargesquare;
697 } 638 }
698 639
699 //....oooOO0OOooo........oooOO0OOooo........oo 640 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
700 641
701 G4double G4EnergyLossTables::GetPreciseRangeF 642 G4double G4EnergyLossTables::GetPreciseRangeFromEnergy(
702 const G4ParticleDefinition *aParticle, 643 const G4ParticleDefinition *aParticle,
703 G4double KineticEnergy, 644 G4double KineticEnergy,
704 const G4Material *aMaterial) 645 const G4Material *aMaterial)
705 { 646 {
706 if (!t) t = new G4EnergyLossTablesHelper; <<
707 <<
708 CPRWarning(); 647 CPRWarning();
709 if( aParticle != (const G4ParticleDefinition << 648 if( aParticle != lastParticle)
710 { 649 {
711 *t= GetTables(aParticle); << 650 t= GetTables(aParticle);
712 lastParticle = (G4ParticleDefinition*) aPa << 651 lastParticle = aParticle;
713 Chargesquare = (aParticle->GetPDGCharge()) 652 Chargesquare = (aParticle->GetPDGCharge())*
714 (aParticle->GetPDGCharge()) 653 (aParticle->GetPDGCharge())/
715 QQPositron ; 654 QQPositron ;
716 oldIndex = -1 ; 655 oldIndex = -1 ;
717 } 656 }
718 const G4PhysicsTable* rangeTable= t->theRang << 657 const G4PhysicsTable* rangeTable= t.theRangeTable;
719 const G4PhysicsTable* dEdxTable= t->theDEDX << 658 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
720 if (!rangeTable) { << 659 if (!dEdxTable || !rangeTable) ParticleHaveNoLoss(aParticle);
721 ParticleHaveNoLoss(aParticle,"Range"); << 660
722 return 0.0; << 661 G4int materialIndex = aMaterial->GetIndex();
723 } <<
724 G4int materialIndex = (G4int)aMaterial->GetI <<
725 662
726 G4double Thighr = t->theHighestKineticEnergy << 663 G4double Thighr = t.theHighestKineticEnergy*t.theLowestKineticEnergy/
727 (*rangeTable)(materialIndex 664 (*rangeTable)(materialIndex)->
728 GetLowEdgeEnergy(1) ; 665 GetLowEdgeEnergy(1) ;
729 666
730 G4double scaledKineticEnergy = KineticEnergy << 667 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
731 G4double Range; 668 G4double Range;
732 G4bool isOut; 669 G4bool isOut;
733 670
734 if (scaledKineticEnergy<t->theLowestKineticE << 671 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
735 672
736 Range = std::sqrt(scaledKineticEnergy/t->t << 673 Range = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)*
737 (*rangeTable)(materialIndex)->GetV 674 (*rangeTable)(materialIndex)->GetValue(
738 t->theLowestKineticEnergy,isOut) << 675 t.theLowestKineticEnergy,isOut);
739 676
740 } else if (scaledKineticEnergy>Thighr) { 677 } else if (scaledKineticEnergy>Thighr) {
741 678
742 Range = (*rangeTable)(materialIndex)->GetV 679 Range = (*rangeTable)(materialIndex)->GetValue(
743 Thighr,isOut)+ 680 Thighr,isOut)+
744 (scaledKineticEnergy-Thighr)/ 681 (scaledKineticEnergy-Thighr)/
745 (*dEdxTable)(materialIndex)->GetVa 682 (*dEdxTable)(materialIndex)->GetValue(
746 Thighr,isOut); 683 Thighr,isOut);
747 684
748 } else { 685 } else {
749 686
750 Range = (*rangeTable)(materialIndex)->Get 687 Range = (*rangeTable)(materialIndex)->GetValue(
751 scaledKineticEnergy,isO 688 scaledKineticEnergy,isOut) ;
752 689
753 } 690 }
754 691
755 return Range/(Chargesquare*t->theMassRatio); << 692 return Range/(Chargesquare*t.theMassRatio);
756 } 693 }
757 694
758 //....oooOO0OOooo........oooOO0OOooo........oo 695 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
759 696
760 G4double G4EnergyLossTables::GetDEDX( 697 G4double G4EnergyLossTables::GetDEDX(
761 const G4ParticleDefinition *aParticle, 698 const G4ParticleDefinition *aParticle,
762 G4double KineticEnergy, 699 G4double KineticEnergy,
763 const G4MaterialCutsCouple *couple, << 700 const G4MaterialCutsCouple *couple)
764 G4bool check) <<
765 { 701 {
766 if (!t) t = new G4EnergyLossTablesHelper; << 702 if(aParticle != lastParticle)
767 <<
768 if(aParticle != (const G4ParticleDefinition* <<
769 { 703 {
770 *t= GetTables(aParticle); << 704 t= GetTables(aParticle);
771 lastParticle = (G4ParticleDefinition*) aPa << 705 lastParticle = aParticle ;
772 Chargesquare = (aParticle->GetPDGCharge()) 706 Chargesquare = (aParticle->GetPDGCharge())*
773 (aParticle->GetPDGCharge()) 707 (aParticle->GetPDGCharge())/
774 QQPositron ; 708 QQPositron ;
775 oldIndex = -1 ; 709 oldIndex = -1 ;
776 } 710 }
777 const G4PhysicsTable* dEdxTable= t->theDEDX << 711 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
778 << 712 if ( !dEdxTable )
779 if (!dEdxTable ) { << 713 return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);
780 if (check) return G4LossTableManager::Inst <<
781 else ParticleHaveNoLoss(aParticle, " <<
782 return 0.0; <<
783 } <<
784 714
785 G4int materialIndex = couple->GetIndex(); 715 G4int materialIndex = couple->GetIndex();
786 G4double scaledKineticEnergy = KineticEnergy << 716 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
787 G4double dEdx; 717 G4double dEdx;
788 G4bool isOut; 718 G4bool isOut;
789 719
790 if (scaledKineticEnergy<t->theLowestKineticE << 720 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
791 721
792 dEdx =(*dEdxTable)(materialIndex)->GetVal 722 dEdx =(*dEdxTable)(materialIndex)->GetValue(
793 t->theLowestKineticEnergy,isOut) << 723 t.theLowestKineticEnergy,isOut)
794 *std::sqrt(scaledKineticEnergy/t->t << 724 *sqrt(scaledKineticEnergy/t.theLowestKineticEnergy);
795 725
796 } else if (scaledKineticEnergy>t->theHighest << 726 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
797 727
798 dEdx = (*dEdxTable)(materialIndex)->GetVa 728 dEdx = (*dEdxTable)(materialIndex)->GetValue(
799 t->theHighestKineticEnergy,isOut); << 729 t.theHighestKineticEnergy,isOut);
800 730
801 } else { 731 } else {
802 732
803 dEdx = (*dEdxTable)(materialIndex)->GetVal 733 dEdx = (*dEdxTable)(materialIndex)->GetValue(
804 scaledKineticEnergy,isOut); 734 scaledKineticEnergy,isOut);
805 735
806 } 736 }
807 737
808 return dEdx*Chargesquare; 738 return dEdx*Chargesquare;
809 } 739 }
810 740
811 //....oooOO0OOooo........oooOO0OOooo........oo 741 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
812 742
813 G4double G4EnergyLossTables::GetRange( 743 G4double G4EnergyLossTables::GetRange(
814 const G4ParticleDefinition *aParticle, 744 const G4ParticleDefinition *aParticle,
815 G4double KineticEnergy, 745 G4double KineticEnergy,
816 const G4MaterialCutsCouple *couple, << 746 const G4MaterialCutsCouple *couple)
817 G4bool check) <<
818 { 747 {
819 if (!t) t = new G4EnergyLossTablesHelper; << 748 if(aParticle != lastParticle)
820 <<
821 if(aParticle != (const G4ParticleDefinition* <<
822 { 749 {
823 *t= GetTables(aParticle); << 750 t= GetTables(aParticle);
824 lastParticle = (G4ParticleDefinition*) aPa << 751 lastParticle = aParticle ;
825 Chargesquare = (aParticle->GetPDGCharge()) 752 Chargesquare = (aParticle->GetPDGCharge())*
826 (aParticle->GetPDGCharge()) 753 (aParticle->GetPDGCharge())/
827 QQPositron ; 754 QQPositron ;
828 oldIndex = -1 ; 755 oldIndex = -1 ;
829 } 756 }
830 const G4PhysicsTable* rangeTable= t->theRang << 757 const G4PhysicsTable* rangeTable= t.theRangeTable;
831 const G4PhysicsTable* dEdxTable= t->theDEDX << 758 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
832 if (!rangeTable) { << 759 if ( !rangeTable || !dEdxTable)
833 if(check) return G4LossTableManager::Insta << 760 return G4LossTableManager::Instance()->GetRange(aParticle,KineticEnergy,couple);
834 else return DBL_MAX; << 761
835 //ParticleHaveNoLoss(aParticle,"Range"); <<
836 } <<
837 762
838 G4int materialIndex = couple->GetIndex(); 763 G4int materialIndex = couple->GetIndex();
839 G4double scaledKineticEnergy = KineticEnergy << 764 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
840 G4double Range; 765 G4double Range;
841 G4bool isOut; 766 G4bool isOut;
842 767
843 if (scaledKineticEnergy<t->theLowestKineticE << 768 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
844 769
845 Range = std::sqrt(scaledKineticEnergy/t->t << 770 Range = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)*
846 (*rangeTable)(materialIndex)->GetV 771 (*rangeTable)(materialIndex)->GetValue(
847 t->theLowestKineticEnergy,isOut) << 772 t.theLowestKineticEnergy,isOut);
848 773
849 } else if (scaledKineticEnergy>t->theHighest << 774 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
850 775
851 Range = (*rangeTable)(materialIndex)->GetV 776 Range = (*rangeTable)(materialIndex)->GetValue(
852 t->theHighestKineticEnergy,isOut)+ << 777 t.theHighestKineticEnergy,isOut)+
853 (scaledKineticEnergy-t->theHighest << 778 (scaledKineticEnergy-t.theHighestKineticEnergy)/
854 (*dEdxTable)(materialIndex)->GetVa 779 (*dEdxTable)(materialIndex)->GetValue(
855 t->theHighestKineticEnergy,isOut << 780 t.theHighestKineticEnergy,isOut);
856 781
857 } else { 782 } else {
858 783
859 Range = (*rangeTable)(materialIndex)->GetV 784 Range = (*rangeTable)(materialIndex)->GetValue(
860 scaledKineticEnergy,isOut); 785 scaledKineticEnergy,isOut);
861 786
862 } 787 }
863 788
864 return Range/(Chargesquare*t->theMassRatio); << 789 return Range/(Chargesquare*t.theMassRatio);
865 } 790 }
866 791
867 //....oooOO0OOooo........oooOO0OOooo........oo 792 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
868 793
869 G4double G4EnergyLossTables::GetPreciseEnergyF 794 G4double G4EnergyLossTables::GetPreciseEnergyFromRange(
870 const G4P 795 const G4ParticleDefinition *aParticle,
871 G4d 796 G4double range,
872 const G4M << 797 const G4MaterialCutsCouple *couple)
873 G4bool check) <<
874 // it returns the value of the kinetic energy 798 // it returns the value of the kinetic energy for a given range
875 { 799 {
876 if (!t) t = new G4EnergyLossTablesHelper; << 800 if( aParticle != lastParticle)
877 <<
878 if( aParticle != (const G4ParticleDefinition <<
879 { 801 {
880 *t= GetTables(aParticle); << 802 t= GetTables(aParticle);
881 lastParticle = (G4ParticleDefinition*) aPa << 803 lastParticle = aParticle;
882 Chargesquare = (aParticle->GetPDGCharge()) 804 Chargesquare = (aParticle->GetPDGCharge())*
883 (aParticle->GetPDGCharge()) 805 (aParticle->GetPDGCharge())/
884 QQPositron ; 806 QQPositron ;
885 oldIndex = -1 ; 807 oldIndex = -1 ;
886 } 808 }
887 const G4PhysicsTable* dEdxTable= t->theDEDX << 809 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
888 const G4PhysicsTable* inverseRangeTable= t- << 810 const G4PhysicsTable* inverseRangeTable= t.theInverseRangeTable;
889 << 811 if ( !dEdxTable || !inverseRangeTable)
890 if (!inverseRangeTable) { << 812 return G4LossTableManager::Instance()->GetEnergy(aParticle,range,couple);
891 if(check) return G4LossTableManager::Insta <<
892 else return DBL_MAX; <<
893 // else ParticleHaveNoLoss(aPartic <<
894 } <<
895 813
896 G4double scaledrange,scaledKineticEnergy ; 814 G4double scaledrange,scaledKineticEnergy ;
897 G4bool isOut ; 815 G4bool isOut ;
898 816
899 G4int materialIndex = couple->GetIndex() ; 817 G4int materialIndex = couple->GetIndex() ;
900 818
901 if(materialIndex != oldIndex) 819 if(materialIndex != oldIndex)
902 { 820 {
903 oldIndex = materialIndex ; 821 oldIndex = materialIndex ;
904 rmin = (*inverseRangeTable)(materialIndex) 822 rmin = (*inverseRangeTable)(materialIndex)->
905 GetLowEdgeEnergy 823 GetLowEdgeEnergy(0) ;
906 rmax = (*inverseRangeTable)(materialIndex) 824 rmax = (*inverseRangeTable)(materialIndex)->
907 GetLowEdgeEnergy(t->theNumb << 825 GetLowEdgeEnergy(t.theNumberOfBins-2) ;
908 Thigh = (*inverseRangeTable)(materialIndex 826 Thigh = (*inverseRangeTable)(materialIndex)->
909 GetValue(rmax,is 827 GetValue(rmax,isOut) ;
910 } 828 }
911 829
912 scaledrange = range*Chargesquare*t->theMassR << 830 scaledrange = range*Chargesquare*t.theMassRatio ;
913 831
914 if(scaledrange < rmin) 832 if(scaledrange < rmin)
915 { 833 {
916 scaledKineticEnergy = t->theLowestKineticE << 834 scaledKineticEnergy = t.theLowestKineticEnergy*
917 scaledrange*scaledrange/(rm 835 scaledrange*scaledrange/(rmin*rmin) ;
918 } 836 }
919 else 837 else
920 { 838 {
921 if(scaledrange < rmax) 839 if(scaledrange < rmax)
922 { 840 {
923 scaledKineticEnergy = (*inverseRangeTabl 841 scaledKineticEnergy = (*inverseRangeTable)(materialIndex)->
924 GetValue( scaled 842 GetValue( scaledrange,isOut) ;
925 } 843 }
926 else 844 else
927 { 845 {
928 scaledKineticEnergy = Thigh + 846 scaledKineticEnergy = Thigh +
929 (scaledrange-rmax)* 847 (scaledrange-rmax)*
930 (*dEdxTable)(materialInd 848 (*dEdxTable)(materialIndex)->
931 GetValue(Thig 849 GetValue(Thigh,isOut) ;
932 } 850 }
933 } 851 }
934 852
935 return scaledKineticEnergy/t->theMassRatio ; << 853 return scaledKineticEnergy/t.theMassRatio ;
936 } 854 }
937 855
938 //....oooOO0OOooo........oooOO0OOooo........oo 856 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
939 857
940 G4double G4EnergyLossTables::GetPreciseDEDX( 858 G4double G4EnergyLossTables::GetPreciseDEDX(
941 const G4ParticleDefinition *aParticle, 859 const G4ParticleDefinition *aParticle,
942 G4double KineticEnergy, 860 G4double KineticEnergy,
943 const G4MaterialCutsCouple *couple) 861 const G4MaterialCutsCouple *couple)
944 { 862 {
945 if (!t) t = new G4EnergyLossTablesHelper; <<
946 863
947 if( aParticle != (const G4ParticleDefinition << 864 if( aParticle != lastParticle)
948 { 865 {
949 *t= GetTables(aParticle); << 866 t= GetTables(aParticle);
950 lastParticle = (G4ParticleDefinition*) aPa << 867 lastParticle = aParticle;
951 Chargesquare = (aParticle->GetPDGCharge()) 868 Chargesquare = (aParticle->GetPDGCharge())*
952 (aParticle->GetPDGCharge()) 869 (aParticle->GetPDGCharge())/
953 QQPositron ; 870 QQPositron ;
954 oldIndex = -1 ; 871 oldIndex = -1 ;
955 } 872 }
956 const G4PhysicsTable* dEdxTable= t->theDEDX << 873 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
957 if ( !dEdxTable ) 874 if ( !dEdxTable )
958 return G4LossTableManager::Instance()->Get 875 return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);
959 876
960 G4int materialIndex = couple->GetIndex(); 877 G4int materialIndex = couple->GetIndex();
961 G4double scaledKineticEnergy = KineticEnergy << 878 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
962 G4double dEdx; 879 G4double dEdx;
963 G4bool isOut; 880 G4bool isOut;
964 881
965 if (scaledKineticEnergy<t->theLowestKineticE << 882 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
966 883
967 dEdx = std::sqrt(scaledKineticEnergy/t->t << 884 dEdx = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)
968 *(*dEdxTable)(materialIndex)->GetV 885 *(*dEdxTable)(materialIndex)->GetValue(
969 t->theLowestKineticEnergy,isOut) << 886 t.theLowestKineticEnergy,isOut);
970 887
971 } else if (scaledKineticEnergy>t->theHighest << 888 } else if (scaledKineticEnergy>t.theHighestKineticEnergy) {
972 889
973 dEdx = (*dEdxTable)(materialIndex)->GetVa 890 dEdx = (*dEdxTable)(materialIndex)->GetValue(
974 t->theHighestKineticEnergy,isOut); << 891 t.theHighestKineticEnergy,isOut);
975 892
976 } else { 893 } else {
977 894
978 dEdx = (*dEdxTable)(materialIndex)->GetV 895 dEdx = (*dEdxTable)(materialIndex)->GetValue(
979 scaledKineticEnergy, 896 scaledKineticEnergy,isOut) ;
980 897
981 } 898 }
982 899
983 return dEdx*Chargesquare; 900 return dEdx*Chargesquare;
984 } 901 }
985 902
986 //....oooOO0OOooo........oooOO0OOooo........oo 903 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
987 904
988 G4double G4EnergyLossTables::GetPreciseRangeFr 905 G4double G4EnergyLossTables::GetPreciseRangeFromEnergy(
989 const G4ParticleDefinition *aParticle, 906 const G4ParticleDefinition *aParticle,
990 G4double KineticEnergy, 907 G4double KineticEnergy,
991 const G4MaterialCutsCouple *couple) 908 const G4MaterialCutsCouple *couple)
992 { 909 {
993 if (!t) t = new G4EnergyLossTablesHelper; << 910 if( aParticle != lastParticle)
994 <<
995 if( aParticle != (const G4ParticleDefinition <<
996 { 911 {
997 *t= GetTables(aParticle); << 912 t= GetTables(aParticle);
998 lastParticle = (G4ParticleDefinition*) aPa << 913 lastParticle = aParticle;
999 Chargesquare = (aParticle->GetPDGCharge()) 914 Chargesquare = (aParticle->GetPDGCharge())*
1000 (aParticle->GetPDGCharge() 915 (aParticle->GetPDGCharge())/
1001 QQPositron ; 916 QQPositron ;
1002 oldIndex = -1 ; 917 oldIndex = -1 ;
1003 } 918 }
1004 const G4PhysicsTable* rangeTable= t->theRan << 919 const G4PhysicsTable* rangeTable= t.theRangeTable;
1005 const G4PhysicsTable* dEdxTable= t->theDED << 920 const G4PhysicsTable* dEdxTable= t.theDEDXTable;
1006 if ( !dEdxTable || !rangeTable) 921 if ( !dEdxTable || !rangeTable)
1007 return G4LossTableManager::Instance()->Ge 922 return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);
1008 923
1009 G4int materialIndex = couple->GetIndex(); 924 G4int materialIndex = couple->GetIndex();
1010 925
1011 G4double Thighr = t->theHighestKineticEnerg << 926 G4double Thighr = t.theHighestKineticEnergy*t.theLowestKineticEnergy/
1012 (*rangeTable)(materialInde 927 (*rangeTable)(materialIndex)->
1013 GetLowEdgeEnergy(1) ; 928 GetLowEdgeEnergy(1) ;
1014 929
1015 G4double scaledKineticEnergy = KineticEnerg << 930 G4double scaledKineticEnergy = KineticEnergy*t.theMassRatio;
1016 G4double Range; 931 G4double Range;
1017 G4bool isOut; 932 G4bool isOut;
1018 933
1019 if (scaledKineticEnergy<t->theLowestKinetic << 934 if (scaledKineticEnergy<t.theLowestKineticEnergy) {
1020 935
1021 Range = std::sqrt(scaledKineticEnergy/t-> << 936 Range = sqrt(scaledKineticEnergy/t.theLowestKineticEnergy)*
1022 (*rangeTable)(materialIndex)->Get 937 (*rangeTable)(materialIndex)->GetValue(
1023 t->theLowestKineticEnergy,isOut << 938 t.theLowestKineticEnergy,isOut);
1024 939
1025 } else if (scaledKineticEnergy>Thighr) { 940 } else if (scaledKineticEnergy>Thighr) {
1026 941
1027 Range = (*rangeTable)(materialIndex)->Get 942 Range = (*rangeTable)(materialIndex)->GetValue(
1028 Thighr,isOut)+ 943 Thighr,isOut)+
1029 (scaledKineticEnergy-Thighr)/ 944 (scaledKineticEnergy-Thighr)/
1030 (*dEdxTable)(materialIndex)->GetV 945 (*dEdxTable)(materialIndex)->GetValue(
1031 Thighr,isOut); 946 Thighr,isOut);
1032 947
1033 } else { 948 } else {
1034 949
1035 Range = (*rangeTable)(materialIndex)->Ge 950 Range = (*rangeTable)(materialIndex)->GetValue(
1036 scaledKineticEnergy,is 951 scaledKineticEnergy,isOut) ;
1037 952
1038 } 953 }
1039 954
1040 return Range/(Chargesquare*t->theMassRatio) << 955 return Range/(Chargesquare*t.theMassRatio);
1041 } 956 }
1042 957
1043 //....oooOO0OOooo........oooOO0OOooo........o 958 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1044 959
1045 void G4EnergyLossTables::CPRWarning() 960 void G4EnergyLossTables::CPRWarning()
1046 { 961 {
1047 if (let_counter < let_max_num_warnings) { << 962 // if (let_counter < let_max_num_warnings) {
1048 963
1049 G4cout << G4endl; << 964 // G4cout << G4endl;
1050 G4cout << "##### G4EnergyLossTable WARNIN << 965 // G4cout << "##### G4EnergyLossTable WARNING: The obsolete interface is used" << G4endl;
1051 G4cout << "##### RESULTS ARE NOT GARANTEE << 966 // G4cout << "##### Please, substitute G4Material by G4MaterialCutsCouple" << G4endl;
1052 G4cout << "##### Please, substitute G4Mat << 967 // G4cout << "##### Obsolete interface will be removed soon" << G4endl;
1053 G4cout << "##### Obsolete interface will << 968 // G4cout << G4endl;
1054 G4cout << G4endl; << 969 // let_counter++;
1055 let_counter++; << 970 if ((G4RegionStore::GetInstance())->size() > 1) {
>> 971 G4Exception("G4EnergyLossTables:: More than 1 region - table can't be accessed with obsolete interface");
>> 972 exit(1);
>> 973 }
1056 974
1057 } else if (let_counter == let_max_num_warni << 975 // } else if (let_counter == let_max_num_warnings) {
1058 976
1059 G4cout << "##### G4EnergyLossTable WARNIN << 977 // G4cout << "##### G4EnergyLossTable WARNING closed" << G4endl;
1060 let_counter++; << 978 // let_counter++;
1061 } << 979 // }
1062 } 980 }
1063 981
1064 //....oooOO0OOooo........oooOO0OOooo........o 982 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1065 983
1066 void << 984 void G4EnergyLossTables::ParticleHaveNoLoss(const G4ParticleDefinition* aParticle)
1067 G4EnergyLossTables::ParticleHaveNoLoss(const <<
1068 const G4String& /*q*/) <<
1069 { 985 {
>> 986 G4String s = "G4EnergyLossTables:: dE/dx table not found for "
>> 987 + aParticle->GetParticleName() + "!";
>> 988 G4Exception(s);
>> 989 exit(1);
1070 } 990 }
1071 991
1072 //....oooOO0OOooo........oooOO0OOooo........o 992 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1073 993