| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // 27 //
28 ////////////////////////////////////////////// 28 ////////////////////////////////////////////////////////////////////////
29 // Optical Photon WaveLength Shifting (WLS) Cl 29 // Optical Photon WaveLength Shifting (WLS) Class Implementation
30 ////////////////////////////////////////////// 30 ////////////////////////////////////////////////////////////////////////
31 // 31 //
32 // File: G4OpWLS.cc 32 // File: G4OpWLS.cc
33 // Description: Discrete Process -- Wavelength 33 // Description: Discrete Process -- Wavelength Shifting of Optical Photons
34 // Version: 1.0 34 // Version: 1.0
35 // Created: 2003-05-13 35 // Created: 2003-05-13
36 // Author: John Paul Archambault 36 // Author: John Paul Archambault
37 // (Adaptation of G4Scintillation 37 // (Adaptation of G4Scintillation and G4OpAbsorption)
38 // Updated: 2005-07-28 - add G4ProcessType 38 // Updated: 2005-07-28 - add G4ProcessType to constructor
39 // 2006-05-07 - add G4VWLSTimeGen 39 // 2006-05-07 - add G4VWLSTimeGeneratorProfile
>> 40 // mail: gum@triumf.ca
>> 41 // jparcham@phys.ualberta.ca
40 // 42 //
41 ////////////////////////////////////////////// 43 ////////////////////////////////////////////////////////////////////////
42 44
43 #include "G4OpWLS.hh" 45 #include "G4OpWLS.hh"
>> 46
44 #include "G4ios.hh" 47 #include "G4ios.hh"
45 #include "G4PhysicalConstants.hh" 48 #include "G4PhysicalConstants.hh"
46 #include "G4SystemOfUnits.hh" 49 #include "G4SystemOfUnits.hh"
47 #include "G4OpProcessSubType.hh" 50 #include "G4OpProcessSubType.hh"
48 #include "G4Poisson.hh" << 51
49 #include "G4OpticalParameters.hh" <<
50 #include "G4WLSTimeGeneratorProfileDelta.hh" 52 #include "G4WLSTimeGeneratorProfileDelta.hh"
51 #include "G4WLSTimeGeneratorProfileExponential 53 #include "G4WLSTimeGeneratorProfileExponential.hh"
52 54
53 //....oooOO0OOooo........oooOO0OOooo........oo << 55 /////////////////////////
>> 56 // Class Implementation
>> 57 /////////////////////////
>> 58
>> 59 //////////////////////
>> 60 // static data members
>> 61 //////////////////////
>> 62
>> 63 /////////////////
>> 64 // Constructors
>> 65 /////////////////
>> 66
54 G4OpWLS::G4OpWLS(const G4String& processName, 67 G4OpWLS::G4OpWLS(const G4String& processName, G4ProcessType type)
55 : G4VDiscreteProcess(processName, type) 68 : G4VDiscreteProcess(processName, type)
56 { 69 {
57 WLSTimeGeneratorProfile = nullptr; <<
58 Initialise(); <<
59 SetProcessSubType(fOpWLS); 70 SetProcessSubType(fOpWLS);
60 theIntegralTable = nullptr; <<
61 71
62 if(verboseLevel > 0) << 72 theIntegralTable = NULL;
63 G4cout << GetProcessName() << " is created << 73
>> 74 WLSTimeGeneratorProfile =
>> 75 new G4WLSTimeGeneratorProfileDelta("WLSTimeGeneratorProfileDelta");
>> 76
>> 77 if (verboseLevel>0) G4cout << GetProcessName() << " is created " << G4endl;
64 } 78 }
65 79
66 //....oooOO0OOooo........oooOO0OOooo........oo << 80 ////////////////
>> 81 // Destructors
>> 82 ////////////////
>> 83
67 G4OpWLS::~G4OpWLS() 84 G4OpWLS::~G4OpWLS()
68 { 85 {
69 if(theIntegralTable) << 86 if (theIntegralTable) {
70 { <<
71 theIntegralTable->clearAndDestroy(); 87 theIntegralTable->clearAndDestroy();
72 delete theIntegralTable; 88 delete theIntegralTable;
73 } 89 }
74 delete WLSTimeGeneratorProfile; 90 delete WLSTimeGeneratorProfile;
75 } 91 }
76 92
77 //....oooOO0OOooo........oooOO0OOooo........oo << 93 ////////////
78 void G4OpWLS::PreparePhysicsTable(const G4Part << 94 // Methods
>> 95 ////////////
79 96
80 //....oooOO0OOooo........oooOO0OOooo........oo << 97 // PostStepDoIt
81 void G4OpWLS::Initialise() << 98 // -------------
82 { << 99 //
83 G4OpticalParameters* params = G4OpticalParam << 100 G4VParticleChange*
84 SetVerboseLevel(params->GetWLSVerboseLevel() << 101 G4OpWLS::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
85 UseTimeProfile(params->GetWLSTimeProfile()); <<
86 } <<
87 <<
88 //....oooOO0OOooo........oooOO0OOooo........oo <<
89 G4VParticleChange* G4OpWLS::PostStepDoIt(const <<
90 const <<
91 { 102 {
92 std::vector<G4Track*> proposedSecondaries; 103 std::vector<G4Track*> proposedSecondaries;
93 aParticleChange.Initialize(aTrack); 104 aParticleChange.Initialize(aTrack);
>> 105
94 aParticleChange.ProposeTrackStatus(fStopAndK 106 aParticleChange.ProposeTrackStatus(fStopAndKill);
95 107
96 if(verboseLevel > 1) << 108 if (verboseLevel>0) {
97 { <<
98 G4cout << "\n** G4OpWLS: Photon absorbed! 109 G4cout << "\n** G4OpWLS: Photon absorbed! **" << G4endl;
99 } 110 }
>> 111
>> 112 const G4Material* aMaterial = aTrack.GetMaterial();
100 113
101 G4StepPoint* pPostStepPoint = aStep.GetPostS 114 G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
102 G4MaterialPropertiesTable* MPT = << 115
103 aTrack.GetMaterial()->GetMaterialPropertie << 116 G4MaterialPropertiesTable* aMaterialPropertiesTable =
104 if(!MPT) << 117 aMaterial->GetMaterialPropertiesTable();
105 { << 118 if (!aMaterialPropertiesTable)
106 return G4VDiscreteProcess::PostStepDoIt(aT 119 return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
107 } << 120
108 if(!MPT->GetProperty(kWLSCOMPONENT)) << 121 const G4MaterialPropertyVector* WLS_Intensity =
109 { << 122 aMaterialPropertiesTable->GetProperty(kWLSCOMPONENT);
>> 123
>> 124 if (!WLS_Intensity)
110 return G4VDiscreteProcess::PostStepDoIt(aT 125 return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
111 } <<
112 126
113 G4int NumPhotons = 1; 127 G4int NumPhotons = 1;
114 if(MPT->ConstPropertyExists(kWLSMEANNUMBERPH << 128
115 { << 129 if (aMaterialPropertiesTable->ConstPropertyExists("WLSMEANNUMBERPHOTONS")) {
116 G4double MeanNumberOfPhotons = MPT->GetCon << 130
117 NumPhotons = G4int(G4Poi << 131 G4double MeanNumberOfPhotons = aMaterialPropertiesTable->
118 if(NumPhotons <= 0) << 132 GetConstProperty(kWLSMEANNUMBERPHOTONS);
119 { << 133
120 // return unchanged particle and no seco << 134 NumPhotons = G4int(G4Poisson(MeanNumberOfPhotons));
121 aParticleChange.SetNumberOfSecondaries(0 << 135
122 return G4VDiscreteProcess::PostStepDoIt( << 136 if (NumPhotons <= 0) {
123 } << 137
>> 138 // return unchanged particle and no secondaries
>> 139
>> 140 aParticleChange.SetNumberOfSecondaries(0);
>> 141
>> 142 return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
>> 143
>> 144 }
>> 145
124 } 146 }
125 147
126 // Retrieve the WLS Integral for this materi <<
127 // new G4PhysicsFreeVector allocated to hold <<
128 G4double primaryEnergy = aTrack.GetDynamicPa 148 G4double primaryEnergy = aTrack.GetDynamicParticle()->GetKineticEnergy();
129 G4double WLSTime = 0.; <<
130 G4PhysicsFreeVector* WLSIntegral = nullptr; <<
131 149
132 WLSTime = MPT->GetConstProperty(kWLSTIME << 150 G4int materialIndex = aMaterial->GetIndex();
133 WLSIntegral = (G4PhysicsFreeVector*) ((*theI << 151
134 aTrack.GetMaterial()->GetIndex())); << 152 // Retrieve the WLS Integral for this material
>> 153 // new G4PhysicsOrderedFreeVector allocated to hold CII's
>> 154
>> 155 G4double WLSTime = 0.*ns;
>> 156 G4PhysicsOrderedFreeVector* WLSIntegral = 0;
135 157
>> 158 WLSTime = aMaterialPropertiesTable->
>> 159 GetConstProperty(kWLSTIMECONSTANT);
>> 160 WLSIntegral =
>> 161 (G4PhysicsOrderedFreeVector*)((*theIntegralTable)(materialIndex));
>> 162
136 // Max WLS Integral 163 // Max WLS Integral
137 G4double CIImax = WLSIntegral->GetMaxV << 164
>> 165 G4double CIImax = WLSIntegral->GetMaxValue();
>> 166
138 G4int NumberOfPhotons = NumPhotons; 167 G4int NumberOfPhotons = NumPhotons;
>> 168
>> 169 for (G4int i = 0; i < NumPhotons; i++) {
139 170
140 for(G4int i = 0; i < NumPhotons; ++i) <<
141 { <<
142 G4double sampledEnergy; 171 G4double sampledEnergy;
>> 172
143 // Make sure the energy of the secondary i 173 // Make sure the energy of the secondary is less than that of the primary
144 for(G4int j = 1; j <= 100; ++j) << 174
145 { << 175 for (G4int j = 1; j <= 100; j++) {
146 // Determine photon energy << 176
147 G4double CIIvalue = G4UniformRand() * CI << 177 // Determine photon energy
148 sampledEnergy = WLSIntegral->GetEner << 178
149 if(sampledEnergy <= primaryEnergy) << 179 G4double CIIvalue = G4UniformRand()*CIImax;
150 break; << 180 sampledEnergy = WLSIntegral->GetEnergy(CIIvalue);
>> 181
>> 182 //if (verboseLevel>1) {
>> 183 // G4cout << "G4OpWLS: sampledEnergy = " << sampledEnergy << G4endl;
>> 184 // G4cout << "G4OpWLS: CIIvalue = " << CIIvalue << G4endl;
>> 185 //}
>> 186
>> 187 if (sampledEnergy <= primaryEnergy) break;
151 } 188 }
>> 189
152 // If no such energy can be sampled, retur 190 // If no such energy can be sampled, return one less secondary, or none
153 if(sampledEnergy > primaryEnergy) << 191
154 { << 192 if (sampledEnergy > primaryEnergy) {
155 if(verboseLevel > 1) << 193 if (verboseLevel>1) {
156 { << 194 G4cout << " *** G4OpWLS: One less WLS photon will be returned ***"
157 G4cout << " *** G4OpWLS: One less WLS << 195 << G4endl;
158 << G4endl; <<
159 } <<
160 NumberOfPhotons--; <<
161 if(NumberOfPhotons == 0) <<
162 { <<
163 if(verboseLevel > 1) <<
164 { <<
165 G4cout <<
166 << " *** G4OpWLS: No WLS photon ca <<
167 << G4endl; <<
168 } 196 }
169 // return unchanged particle and no se << 197 NumberOfPhotons--;
170 aParticleChange.SetNumberOfSecondaries << 198 if (NumberOfPhotons == 0) {
171 return G4VDiscreteProcess::PostStepDoI << 199 if (verboseLevel>1) {
172 } << 200 G4cout <<
173 continue; << 201 " *** G4OpWLS: No WLS photon can be sampled for this primary ***"
174 } << 202 << G4endl;
175 else if(verboseLevel > 1) << 203 }
176 { << 204 // return unchanged particle and no secondaries
177 G4cout << "G4OpWLS: Created photon with << 205 aParticleChange.SetNumberOfSecondaries(0);
178 << G4endl; << 206 return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
179 } << 207 }
>> 208 continue;
>> 209 } else if (verboseLevel > 0) {
>> 210 G4cout << "G4OpWLS: Created photon with energy: " << sampledEnergy
>> 211 << G4endl;
>> 212 }
180 213
181 // Generate random photon direction 214 // Generate random photon direction
182 G4double cost = 1. - 2. * G4UniformRand(); << 215
183 G4double sint = std::sqrt((1. - cost) * (1 << 216 G4double cost = 1. - 2.*G4UniformRand();
184 G4double phi = twopi * G4UniformRand(); << 217 G4double sint = std::sqrt((1.-cost)*(1.+cost));
>> 218
>> 219 G4double phi = twopi*G4UniformRand();
185 G4double sinp = std::sin(phi); 220 G4double sinp = std::sin(phi);
186 G4double cosp = std::cos(phi); 221 G4double cosp = std::cos(phi);
187 G4ParticleMomentum photonMomentum(sint * c << 222
188 << 223 G4double px = sint*cosp;
189 G4ThreeVector photonPolarization(cost * co << 224 G4double py = sint*sinp;
>> 225 G4double pz = cost;
>> 226
>> 227 // Create photon momentum direction vector
>> 228
>> 229 G4ParticleMomentum photonMomentum(px, py, pz);
>> 230
>> 231 // Determine polarization of new photon
>> 232
>> 233 G4double sx = cost*cosp;
>> 234 G4double sy = cost*sinp;
>> 235 G4double sz = -sint;
>> 236
>> 237 G4ThreeVector photonPolarization(sx, sy, sz);
>> 238
190 G4ThreeVector perp = photonMomentum.cross( 239 G4ThreeVector perp = photonMomentum.cross(photonPolarization);
191 << 240
192 phi = twopi * G4UniformRand << 241 phi = twopi*G4UniformRand();
193 sinp = std::sin(phi); << 242 sinp = std::sin(phi);
194 cosp = std::cos(phi); << 243 cosp = std::cos(phi);
195 photonPolarization = (cosp * photonPolariz << 244
196 << 245 photonPolarization = cosp * photonPolarization + sinp * perp;
>> 246
>> 247 photonPolarization = photonPolarization.unit();
>> 248
197 // Generate a new photon: 249 // Generate a new photon:
198 auto sec_dp = << 250
199 new G4DynamicParticle(G4OpticalPhoton::O << 251 G4DynamicParticle* aWLSPhoton =
200 sec_dp->SetPolarization(photonPolarization << 252 new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(),
201 sec_dp->SetKineticEnergy(sampledEnergy); << 253 photonMomentum);
202 << 254 aWLSPhoton->SetPolarization
203 G4double secTime = pPostStepPoint->GetGlob << 255 (photonPolarization.x(),
204 WLSTimeGeneratorProfile << 256 photonPolarization.y(),
205 G4ThreeVector secPos = pPostStepPoint->Get << 257 photonPolarization.z());
206 G4Track* secTrack = new G4Track(sec_dp, << 258
207 << 259 aWLSPhoton->SetKineticEnergy(sampledEnergy);
208 secTrack->SetTouchableHandle(aTrack.GetTou << 260
209 secTrack->SetParentID(aTrack.GetTrackID()) << 261 // Generate new G4Track object:
>> 262
>> 263 // Must give position of WLS optical photon
>> 264
>> 265 G4double TimeDelay = WLSTimeGeneratorProfile->GenerateTime(WLSTime);
>> 266 G4double aSecondaryTime = (pPostStepPoint->GetGlobalTime()) + TimeDelay;
>> 267
>> 268 G4ThreeVector aSecondaryPosition = pPostStepPoint->GetPosition();
>> 269
>> 270 G4Track* aSecondaryTrack =
>> 271 new G4Track(aWLSPhoton,aSecondaryTime,aSecondaryPosition);
>> 272
>> 273 aSecondaryTrack->SetTouchableHandle(aTrack.GetTouchableHandle());
>> 274 // aSecondaryTrack->SetTouchableHandle((G4VTouchable*)0);
>> 275
>> 276 aSecondaryTrack->SetParentID(aTrack.GetTrackID());
210 277
211 proposedSecondaries.push_back(secTrack); << 278 proposedSecondaries.push_back(aSecondaryTrack);
212 } 279 }
213 280
214 aParticleChange.SetNumberOfSecondaries((G4in << 281 aParticleChange.SetNumberOfSecondaries(proposedSecondaries.size());
215 for(auto sec : proposedSecondaries) << 282 for (auto sec : proposedSecondaries) {
216 { <<
217 aParticleChange.AddSecondary(sec); 283 aParticleChange.AddSecondary(sec);
218 } 284 }
219 if(verboseLevel > 1) << 285 if (verboseLevel>0) {
220 { << 286 G4cout << "\n Exiting from G4OpWLS::DoIt -- NumberOfSecondaries = "
221 G4cout << "\n Exiting from G4OpWLS::DoIt - << 287 << aParticleChange.GetNumberOfSecondaries() << G4endl;
222 << aParticleChange.GetNumberOfSecon <<
223 } 288 }
224 << 289
225 return G4VDiscreteProcess::PostStepDoIt(aTra 290 return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
226 } 291 }
227 292
228 //....oooOO0OOooo........oooOO0OOooo........oo << 293 // BuildPhysicsTable for the wavelength shifting process
>> 294 // --------------------------------------------------
>> 295
229 void G4OpWLS::BuildPhysicsTable(const G4Partic 296 void G4OpWLS::BuildPhysicsTable(const G4ParticleDefinition&)
230 { 297 {
231 if(theIntegralTable) << 298 if (theIntegralTable) {
232 { << 299 theIntegralTable->clearAndDestroy();
233 theIntegralTable->clearAndDestroy(); << 300 delete theIntegralTable;
234 delete theIntegralTable; << 301 theIntegralTable = NULL;
235 theIntegralTable = nullptr; <<
236 } 302 }
237 303
238 const G4MaterialTable* materialTable = G4Mat << 304 const G4MaterialTable* theMaterialTable =
239 std::size_t numOfMaterials = G4Mat << 305 G4Material::GetMaterialTable();
240 theIntegralTable = new G << 306 G4int numOfMaterials = G4Material::GetNumberOfMaterials();
241 << 307
>> 308 // create new physics table
>> 309
>> 310 theIntegralTable = new G4PhysicsTable(numOfMaterials);
>> 311
242 // loop for materials 312 // loop for materials
243 for(std::size_t i = 0; i < numOfMaterials; + << 313
244 { << 314 for (G4int i=0 ; i < numOfMaterials; i++)
245 auto physVector = new G4PhysicsFreeVector( <<
246 <<
247 // Retrieve vector of WLS wavelength inten <<
248 // the material from the material's optica <<
249 G4MaterialPropertiesTable* MPT = <<
250 (*materialTable)[i]->GetMaterialProperti <<
251 if(MPT) <<
252 { 315 {
253 G4MaterialPropertyVector* wlsVector = MP << 316 G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector =
254 if(wlsVector) << 317 new G4PhysicsOrderedFreeVector();
255 { << 318
256 // Retrieve the first intensity point << 319 // Retrieve vector of WLS wavelength intensity for
257 // of (photon energy, intensity) pairs << 320 // the material from the material's optical properties table.
258 G4double currentIN = (*wlsVector)[0]; << 321
259 if(currentIN >= 0.0) << 322 G4Material* aMaterial = (*theMaterialTable)[i];
260 { << 323
261 // Create first (photon energy) << 324 G4MaterialPropertiesTable* aMaterialPropertiesTable =
262 G4double currentPM = wlsVector->Ene << 325 aMaterial->GetMaterialPropertiesTable();
263 G4double currentCII = 0.0; << 326
264 physVector->InsertValues(currentPM, << 327 if (aMaterialPropertiesTable) {
265 << 328
266 // Set previous values to current on << 329 G4MaterialPropertyVector* theWLSVector =
267 G4double prevPM = currentPM; << 330 aMaterialPropertiesTable->GetProperty(kWLSCOMPONENT);
268 G4double prevCII = currentCII; << 331
269 G4double prevIN = currentIN; << 332 if (theWLSVector) {
270 << 333
271 // loop over all (photon energy, int << 334 // Retrieve the first intensity point in vector
272 // pairs stored for this material << 335 // of (photon energy, intensity) pairs
273 for(std::size_t j = 1; j < wlsVector << 336
274 { << 337 G4double currentIN = (*theWLSVector)[0];
275 currentPM = wlsVector->Energy(j); << 338
276 currentIN = (*wlsVector)[j]; << 339 if (currentIN >= 0.0) {
277 currentCII = << 340
278 prevCII + 0.5 * (currentPM - pre << 341 // Create first (photon energy)
279 << 342
280 physVector->InsertValues(currentPM << 343 G4double currentPM = theWLSVector->Energy(0);
281 << 344
282 prevPM = currentPM; << 345 G4double currentCII = 0.0;
283 prevCII = currentCII; << 346
284 prevIN = currentIN; << 347 aPhysicsOrderedFreeVector->
285 } << 348 InsertValues(currentPM , currentCII);
286 } << 349
>> 350 // Set previous values to current ones prior to loop
>> 351
>> 352 G4double prevPM = currentPM;
>> 353 G4double prevCII = currentCII;
>> 354 G4double prevIN = currentIN;
>> 355
>> 356 // loop over all (photon energy, intensity)
>> 357 // pairs stored for this material
>> 358
>> 359 for (size_t j = 1;
>> 360 j < theWLSVector->GetVectorLength();
>> 361 j++)
>> 362 {
>> 363 currentPM = theWLSVector->Energy(j);
>> 364 currentIN = (*theWLSVector)[j];
>> 365
>> 366 currentCII = 0.5 * (prevIN + currentIN);
>> 367
>> 368 currentCII = prevCII +
>> 369 (currentPM - prevPM) * currentCII;
>> 370
>> 371 aPhysicsOrderedFreeVector->
>> 372 InsertValues(currentPM, currentCII);
>> 373
>> 374 prevPM = currentPM;
>> 375 prevCII = currentCII;
>> 376 prevIN = currentIN;
>> 377 }
>> 378 }
>> 379 }
287 } 380 }
>> 381 // The WLS integral for a given material
>> 382 // will be inserted in the table according to the
>> 383 // position of the material in the material table.
>> 384
>> 385 theIntegralTable->insertAt(i,aPhysicsOrderedFreeVector);
288 } 386 }
289 theIntegralTable->insertAt(i, physVector); <<
290 } <<
291 } 387 }
292 388
293 //....oooOO0OOooo........oooOO0OOooo........oo << 389 // GetMeanFreePath
294 G4double G4OpWLS::GetMeanFreePath(const G4Trac << 390 // ---------------
295 G4ForceCondi << 391 //
>> 392 G4double G4OpWLS::GetMeanFreePath(const G4Track& aTrack,
>> 393 G4double ,
>> 394 G4ForceCondition* )
296 { 395 {
297 G4double thePhotonEnergy = aTrack.GetDynamic << 396 const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
298 G4double attLength = DBL_MAX; << 397 const G4Material* aMaterial = aTrack.GetMaterial();
299 G4MaterialPropertiesTable* MPT = << 398
300 aTrack.GetMaterial()->GetMaterialPropertie << 399 G4double thePhotonEnergy = aParticle->GetTotalEnergy();
301 << 400
302 if(MPT) << 401 G4MaterialPropertiesTable* aMaterialPropertyTable;
303 { << 402 G4MaterialPropertyVector* AttenuationLengthVector;
304 G4MaterialPropertyVector* attVector = MPT- << 403
305 if(attVector) << 404 G4double AttenuationLength = DBL_MAX;
306 { << 405
307 attLength = attVector->Value(thePhotonEn << 406 aMaterialPropertyTable = aMaterial->GetMaterialPropertiesTable();
>> 407
>> 408 if ( aMaterialPropertyTable ) {
>> 409 AttenuationLengthVector = aMaterialPropertyTable->
>> 410 GetProperty(kWLSABSLENGTH);
>> 411 if ( AttenuationLengthVector ){
>> 412 AttenuationLength = AttenuationLengthVector->
>> 413 Value(thePhotonEnergy);
308 } 414 }
>> 415 else {
>> 416 // G4cout << "No WLS absorption length specified" << G4endl;
>> 417 }
>> 418 }
>> 419 else {
>> 420 // G4cout << "No WLS absortion length specified" << G4endl;
309 } 421 }
310 return attLength; << 422
>> 423 return AttenuationLength;
311 } 424 }
312 425
313 //....oooOO0OOooo........oooOO0OOooo........oo <<
314 void G4OpWLS::UseTimeProfile(const G4String na 426 void G4OpWLS::UseTimeProfile(const G4String name)
315 { 427 {
316 if(WLSTimeGeneratorProfile) << 428 if (name == "delta")
317 { << 429 {
318 delete WLSTimeGeneratorProfile; << 430 delete WLSTimeGeneratorProfile;
319 WLSTimeGeneratorProfile = nullptr; << 431 WLSTimeGeneratorProfile =
320 } << 432 new G4WLSTimeGeneratorProfileDelta("delta");
321 if(name == "delta") << 433 }
322 { << 434 else if (name == "exponential")
323 WLSTimeGeneratorProfile = new G4WLSTimeGen << 435 {
324 } << 436 delete WLSTimeGeneratorProfile;
325 else if(name == "exponential") << 437 WLSTimeGeneratorProfile =
326 { << 438 new G4WLSTimeGeneratorProfileExponential("exponential");
327 WLSTimeGeneratorProfile = << 439 }
328 new G4WLSTimeGeneratorProfileExponential <<
329 } <<
330 else 440 else
331 { << 441 {
332 G4Exception("G4OpWLS::UseTimeProfile", "em << 442 G4Exception("G4OpWLS::UseTimeProfile", "em0202",
333 "generator does not exist"); << 443 FatalException,
334 } << 444 "generator does not exist");
335 G4OpticalParameters::Instance()->SetWLSTimeP << 445 }
336 } <<
337 <<
338 //....oooOO0OOooo........oooOO0OOooo........oo <<
339 void G4OpWLS::SetVerboseLevel(G4int verbose) <<
340 { <<
341 verboseLevel = verbose; <<
342 G4OpticalParameters::Instance()->SetWLSVerbo <<
343 } 446 }
344 447