| 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 ////////////////////////////////////////////// 29 ////////////////////////////////////////////////////////////////////////
30 // Optical Photon Boundary Process Class Defin 30 // Optical Photon Boundary Process Class Definition
31 ////////////////////////////////////////////// 31 ////////////////////////////////////////////////////////////////////////
32 // 32 //
33 // File: G4OpBoundaryProcess.hh 33 // File: G4OpBoundaryProcess.hh
34 // Description: Discrete Process -- reflection 34 // Description: Discrete Process -- reflection/refraction at
35 // optical in 35 // optical interfaces
36 // Version: 1.1 36 // Version: 1.1
37 // Created: 1997-06-18 37 // Created: 1997-06-18
38 // Modified: 2005-07-28 add G4ProcessType t 38 // Modified: 2005-07-28 add G4ProcessType to constructor
39 // 1999-10-29 add method and clas 39 // 1999-10-29 add method and class descriptors
40 // 1999-10-10 - Fill NewMomentum/ 40 // 1999-10-10 - Fill NewMomentum/NewPolarization in
41 // DoAbsorption. The 41 // DoAbsorption. These members need to be
42 // filled since DoIt 42 // filled since DoIt calls
43 // aParticleChange.S 43 // aParticleChange.SetMomentumChange etc.
44 // upon return (than 44 // upon return (thanks to: Clark McGrew)
45 // 2006-11-04 - add capability of 45 // 2006-11-04 - add capability of calculating the reflectivity
46 // off a metal surfa 46 // off a metal surface by way of a complex index
47 // of refraction - T 47 // of refraction - Thanks to Sehwook Lee and John
48 // Hauptman (Dept. o 48 // Hauptman (Dept. of Physics - Iowa State Univ.)
49 // 2009-11-10 - add capability of 49 // 2009-11-10 - add capability of simulating surface reflections
50 // with Look-Up-Tabl 50 // with Look-Up-Tables (LUT) containing measured
51 // optical reflectan 51 // optical reflectance for a variety of surface
52 // treatments - Than 52 // treatments - Thanks to Martin Janecek and
53 // William Moses (La 53 // William Moses (Lawrence Berkeley National Lab.)
54 // 2013-06-01 - add the capabilit 54 // 2013-06-01 - add the capability of simulating the transmission
55 // of a dichronic fi 55 // of a dichronic filter
56 // 2017-02-24 - add capability of 56 // 2017-02-24 - add capability of simulating surface reflections
57 // with Look-Up-Tabl 57 // with Look-Up-Tables (LUT) developed in DAVIS
58 // 58 //
59 // Author: Peter Gumplinger 59 // Author: Peter Gumplinger
60 // adopted from work by Werner Ke 60 // adopted from work by Werner Keil - April 2/96
61 // 61 //
62 ////////////////////////////////////////////// 62 ////////////////////////////////////////////////////////////////////////
63 63
64 #ifndef G4OpBoundaryProcess_h 64 #ifndef G4OpBoundaryProcess_h
65 #define G4OpBoundaryProcess_h 1 65 #define G4OpBoundaryProcess_h 1
66 66
67 #include "G4OpticalPhoton.hh" 67 #include "G4OpticalPhoton.hh"
68 #include "G4OpticalSurface.hh" 68 #include "G4OpticalSurface.hh"
69 #include "G4RandomTools.hh" 69 #include "G4RandomTools.hh"
70 #include "G4VDiscreteProcess.hh" 70 #include "G4VDiscreteProcess.hh"
71 71
72 enum G4OpBoundaryProcessStatus 72 enum G4OpBoundaryProcessStatus
73 { 73 {
74 Undefined, 74 Undefined,
75 Transmission, 75 Transmission,
76 FresnelRefraction, 76 FresnelRefraction,
77 FresnelReflection, 77 FresnelReflection,
78 TotalInternalReflection, 78 TotalInternalReflection,
79 LambertianReflection, 79 LambertianReflection,
80 LobeReflection, 80 LobeReflection,
81 SpikeReflection, 81 SpikeReflection,
82 BackScattering, 82 BackScattering,
83 Absorption, 83 Absorption,
84 Detection, 84 Detection,
85 NotAtBoundary, 85 NotAtBoundary,
86 SameMaterial, 86 SameMaterial,
87 StepTooSmall, 87 StepTooSmall,
88 NoRINDEX, 88 NoRINDEX,
89 PolishedLumirrorAirReflection, 89 PolishedLumirrorAirReflection,
90 PolishedLumirrorGlueReflection, 90 PolishedLumirrorGlueReflection,
91 PolishedAirReflection, 91 PolishedAirReflection,
92 PolishedTeflonAirReflection, 92 PolishedTeflonAirReflection,
93 PolishedTiOAirReflection, 93 PolishedTiOAirReflection,
94 PolishedTyvekAirReflection, 94 PolishedTyvekAirReflection,
95 PolishedVM2000AirReflection, 95 PolishedVM2000AirReflection,
96 PolishedVM2000GlueReflection, 96 PolishedVM2000GlueReflection,
97 EtchedLumirrorAirReflection, 97 EtchedLumirrorAirReflection,
98 EtchedLumirrorGlueReflection, 98 EtchedLumirrorGlueReflection,
99 EtchedAirReflection, 99 EtchedAirReflection,
100 EtchedTeflonAirReflection, 100 EtchedTeflonAirReflection,
101 EtchedTiOAirReflection, 101 EtchedTiOAirReflection,
102 EtchedTyvekAirReflection, 102 EtchedTyvekAirReflection,
103 EtchedVM2000AirReflection, 103 EtchedVM2000AirReflection,
104 EtchedVM2000GlueReflection, 104 EtchedVM2000GlueReflection,
105 GroundLumirrorAirReflection, 105 GroundLumirrorAirReflection,
106 GroundLumirrorGlueReflection, 106 GroundLumirrorGlueReflection,
107 GroundAirReflection, 107 GroundAirReflection,
108 GroundTeflonAirReflection, 108 GroundTeflonAirReflection,
109 GroundTiOAirReflection, 109 GroundTiOAirReflection,
110 GroundTyvekAirReflection, 110 GroundTyvekAirReflection,
111 GroundVM2000AirReflection, 111 GroundVM2000AirReflection,
112 GroundVM2000GlueReflection, 112 GroundVM2000GlueReflection,
113 Dichroic, 113 Dichroic,
114 CoatedDielectricReflection, 114 CoatedDielectricReflection,
115 CoatedDielectricRefraction, 115 CoatedDielectricRefraction,
116 CoatedDielectricFrustratedTransmission 116 CoatedDielectricFrustratedTransmission
117 }; 117 };
118 118
119 class G4OpBoundaryProcess : public G4VDiscrete 119 class G4OpBoundaryProcess : public G4VDiscreteProcess
120 { 120 {
121 public: 121 public:
122 explicit G4OpBoundaryProcess(const G4String& 122 explicit G4OpBoundaryProcess(const G4String& processName = "OpBoundary",
123 G4ProcessType t 123 G4ProcessType type = fOptical);
124 virtual ~G4OpBoundaryProcess(); 124 virtual ~G4OpBoundaryProcess();
125 125
126 virtual G4bool IsApplicable( 126 virtual G4bool IsApplicable(
127 const G4ParticleDefinition& aParticleType) 127 const G4ParticleDefinition& aParticleType) override;
128 // Returns true -> 'is applicable' only for 128 // Returns true -> 'is applicable' only for an optical photon.
129 129
130 virtual G4double GetMeanFreePath(const G4Tra 130 virtual G4double GetMeanFreePath(const G4Track&, G4double,
131 G4ForceCond 131 G4ForceCondition* condition) override;
132 // Returns infinity; i. e. the process does 132 // Returns infinity; i. e. the process does not limit the step, but sets the
133 // 'Forced' condition for the DoIt to be inv 133 // 'Forced' condition for the DoIt to be invoked at every step. However, only
134 // at a boundary will any action be taken. 134 // at a boundary will any action be taken.
135 135
136 G4VParticleChange* PostStepDoIt(const G4Trac 136 G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
137 const G4Step 137 const G4Step& aStep) override;
138 // This is the method implementing boundary 138 // This is the method implementing boundary processes.
139 139
140 virtual G4OpBoundaryProcessStatus GetStatus( 140 virtual G4OpBoundaryProcessStatus GetStatus() const;
141 // Returns the current status. 141 // Returns the current status.
142 142
143 virtual void SetInvokeSD(G4bool); 143 virtual void SetInvokeSD(G4bool);
144 // Set flag for call to InvokeSD method. 144 // Set flag for call to InvokeSD method.
145 145
146 virtual void PreparePhysicsTable(const G4Par 146 virtual void PreparePhysicsTable(const G4ParticleDefinition&) override;
147 147
148 virtual void Initialise(); 148 virtual void Initialise();
149 149
150 void SetVerboseLevel(G4int); 150 void SetVerboseLevel(G4int);
151 151
152 private: 152 private:
153 G4OpBoundaryProcess(const G4OpBoundaryProces 153 G4OpBoundaryProcess(const G4OpBoundaryProcess& right) = delete;
154 G4OpBoundaryProcess& operator=(const G4OpBou 154 G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess& right) = delete;
155 155
156 G4bool G4BooleanRand(const G4double prob) co 156 G4bool G4BooleanRand(const G4double prob) const;
157 157
158 G4ThreeVector GetFacetNormal(const G4ThreeVe 158 G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum,
159 const G4ThreeVe 159 const G4ThreeVector& Normal) const;
160 160
161 void DielectricMetal(); 161 void DielectricMetal();
162 void DielectricDielectric(); 162 void DielectricDielectric();
163 163
164 void DielectricLUT(); 164 void DielectricLUT();
165 void DielectricLUTDAVIS(); 165 void DielectricLUTDAVIS();
166 166
167 void DielectricDichroic(); 167 void DielectricDichroic();
168 void CoatedDielectricDielectric(); 168 void CoatedDielectricDielectric();
169 169
170 void ChooseReflection(); 170 void ChooseReflection();
171 void DoAbsorption(); 171 void DoAbsorption();
172 void DoReflection(); 172 void DoReflection();
173 173
174 G4double GetIncidentAngle(); 174 G4double GetIncidentAngle();
175 // Returns the incident angle of optical pho 175 // Returns the incident angle of optical photon
176 176
177 G4double GetReflectivity(G4double E1_perp, G 177 G4double GetReflectivity(G4double E1_perp, G4double E1_parl,
178 G4double incidentan 178 G4double incidentangle, G4double RealRindex,
179 G4double ImaginaryR 179 G4double ImaginaryRindex);
180 // Returns the Reflectivity on a metallic su 180 // Returns the Reflectivity on a metallic surface
181 181
182 G4double GetReflectivityThroughThinLayer(G4d 182 G4double GetReflectivityThroughThinLayer(G4double sinTL, G4double E1_perp,
183 G4d 183 G4double E1_parl, G4double wavelength,
184 G4d 184 G4double cost1, G4double cost2);
185 // Returns the Reflectivity on a coated surf 185 // Returns the Reflectivity on a coated surface
186 186
187 void CalculateReflectivity(); 187 void CalculateReflectivity();
188 188
189 void BoundaryProcessVerbose() const; 189 void BoundaryProcessVerbose() const;
190 190
191 // Invoke SD for post step point if the phot 191 // Invoke SD for post step point if the photon is 'detected'
192 G4bool InvokeSD(const G4Step* step); 192 G4bool InvokeSD(const G4Step* step);
193 193
194 G4ThreeVector fOldMomentum; 194 G4ThreeVector fOldMomentum;
195 G4ThreeVector fOldPolarization; 195 G4ThreeVector fOldPolarization;
196 196
197 G4ThreeVector fNewMomentum; 197 G4ThreeVector fNewMomentum;
198 G4ThreeVector fNewPolarization; 198 G4ThreeVector fNewPolarization;
199 199
200 G4ThreeVector fGlobalNormal; 200 G4ThreeVector fGlobalNormal;
201 G4ThreeVector fFacetNormal; 201 G4ThreeVector fFacetNormal;
202 202
203 const G4Material* fMaterial1; 203 const G4Material* fMaterial1;
204 const G4Material* fMaterial2; 204 const G4Material* fMaterial2;
205 205
206 G4OpticalSurface* fOpticalSurface; 206 G4OpticalSurface* fOpticalSurface;
207 207
208 G4MaterialPropertyVector* fRealRIndexMPV; 208 G4MaterialPropertyVector* fRealRIndexMPV;
209 G4MaterialPropertyVector* fImagRIndexMPV; 209 G4MaterialPropertyVector* fImagRIndexMPV;
210 G4Physics2DVector* fDichroicVector; 210 G4Physics2DVector* fDichroicVector;
211 211
212 G4double fPhotonMomentum; 212 G4double fPhotonMomentum;
213 G4double fRindex1; 213 G4double fRindex1;
214 G4double fRindex2; 214 G4double fRindex2;
215 215
216 G4double fSint1; 216 G4double fSint1;
217 217
218 G4double fReflectivity; 218 G4double fReflectivity;
219 G4double fEfficiency; 219 G4double fEfficiency;
220 G4double fTransmittance; 220 G4double fTransmittance;
221 G4double fSurfaceRoughness; 221 G4double fSurfaceRoughness;
222 222
223 G4double fProb_sl, fProb_ss, fProb_bs; 223 G4double fProb_sl, fProb_ss, fProb_bs;
224 G4double fCarTolerance; 224 G4double fCarTolerance;
225 225
226 // Used by CoatedDielectricDielectric() 226 // Used by CoatedDielectricDielectric()
227 G4double fCoatedRindex, fCoatedThickness; 227 G4double fCoatedRindex, fCoatedThickness;
228 228
229 G4OpBoundaryProcessStatus fStatus; 229 G4OpBoundaryProcessStatus fStatus;
230 G4OpticalSurfaceModel fModel; 230 G4OpticalSurfaceModel fModel;
231 G4OpticalSurfaceFinish fFinish; 231 G4OpticalSurfaceFinish fFinish;
232 232
233 G4int f_iTE, f_iTM; 233 G4int f_iTE, f_iTM;
234 234
235 G4int fNumSmallStepWarnings = 0; // number o 235 G4int fNumSmallStepWarnings = 0; // number of times small step warning printed
236 G4int fNumBdryTypeWarnings = 0; // number o 236 G4int fNumBdryTypeWarnings = 0; // number of times boundary type warning printed
237 237
238 size_t idx_dichroicX = 0; 238 size_t idx_dichroicX = 0;
239 size_t idx_dichroicY = 0; 239 size_t idx_dichroicY = 0;
240 size_t idx_rindex1 = 0; 240 size_t idx_rindex1 = 0;
241 size_t idx_rindex_surface = 0; 241 size_t idx_rindex_surface = 0;
242 size_t idx_reflect = 0; 242 size_t idx_reflect = 0;
243 size_t idx_eff = 0; 243 size_t idx_eff = 0;
244 size_t idx_trans = 0; 244 size_t idx_trans = 0;
245 size_t idx_lobe = 0; 245 size_t idx_lobe = 0;
246 size_t idx_spike = 0; 246 size_t idx_spike = 0;
247 size_t idx_back = 0; 247 size_t idx_back = 0;
248 size_t idx_rindex2 = 0; 248 size_t idx_rindex2 = 0;
249 size_t idx_groupvel = 0; 249 size_t idx_groupvel = 0;
250 size_t idx_rrindex = 0; 250 size_t idx_rrindex = 0;
251 size_t idx_irindex = 0; 251 size_t idx_irindex = 0;
252 size_t idx_coatedrindex = 0; 252 size_t idx_coatedrindex = 0;
253 253
254 // Used by CoatedDielectricDielectric() 254 // Used by CoatedDielectricDielectric()
255 G4bool fCoatedFrustratedTransmission = true; 255 G4bool fCoatedFrustratedTransmission = true;
256 256
257 G4bool fInvokeSD; 257 G4bool fInvokeSD;
258 }; 258 };
259 259
260 //////////////////// 260 ////////////////////
261 // Inline methods 261 // Inline methods
262 //////////////////// 262 ////////////////////
263 263
264 inline G4bool G4OpBoundaryProcess::G4BooleanRa 264 inline G4bool G4OpBoundaryProcess::G4BooleanRand(const G4double prob) const
265 { 265 {
266 // Returns a random boolean variable with th 266 // Returns a random boolean variable with the specified probability
267 return (G4UniformRand() < prob); 267 return (G4UniformRand() < prob);
268 } 268 }
269 269
270 inline G4bool G4OpBoundaryProcess::IsApplicabl 270 inline G4bool G4OpBoundaryProcess::IsApplicable(
271 const G4ParticleDefinition& aParticleType) 271 const G4ParticleDefinition& aParticleType)
272 { 272 {
273 return (&aParticleType == G4OpticalPhoton::O 273 return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
274 } 274 }
275 275
276 inline G4OpBoundaryProcessStatus G4OpBoundaryP 276 inline G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus() const
277 { 277 {
278 return fStatus; 278 return fStatus;
279 } 279 }
280 280
281 inline void G4OpBoundaryProcess::ChooseReflect 281 inline void G4OpBoundaryProcess::ChooseReflection()
282 { 282 {
283 G4double rand = G4UniformRand(); 283 G4double rand = G4UniformRand();
284 if(rand < fProb_ss) 284 if(rand < fProb_ss)
285 { 285 {
286 fStatus = SpikeReflection; 286 fStatus = SpikeReflection;
287 fFacetNormal = fGlobalNormal; 287 fFacetNormal = fGlobalNormal;
288 } 288 }
289 else if(rand < fProb_ss + fProb_sl) 289 else if(rand < fProb_ss + fProb_sl)
290 { 290 {
291 fStatus = LobeReflection; 291 fStatus = LobeReflection;
292 } 292 }
293 else if(rand < fProb_ss + fProb_sl + fProb_b 293 else if(rand < fProb_ss + fProb_sl + fProb_bs)
294 { 294 {
295 fStatus = BackScattering; 295 fStatus = BackScattering;
296 } 296 }
297 else 297 else
298 { 298 {
299 fStatus = LambertianReflection; 299 fStatus = LambertianReflection;
300 } 300 }
301 } 301 }
302 302
303 inline void G4OpBoundaryProcess::DoAbsorption( 303 inline void G4OpBoundaryProcess::DoAbsorption()
304 { 304 {
305 fStatus = Absorption; 305 fStatus = Absorption;
306 306
307 if(G4BooleanRand(fEfficiency)) 307 if(G4BooleanRand(fEfficiency))
308 { 308 {
309 // EnergyDeposited =/= 0 means: photon has 309 // EnergyDeposited =/= 0 means: photon has been detected
310 fStatus = Detection; 310 fStatus = Detection;
311 aParticleChange.ProposeLocalEnergyDeposit( 311 aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
312 } 312 }
313 else 313 else
314 { 314 {
315 aParticleChange.ProposeLocalEnergyDeposit( 315 aParticleChange.ProposeLocalEnergyDeposit(0.0);
316 } 316 }
317 317
318 fNewMomentum = fOldMomentum; 318 fNewMomentum = fOldMomentum;
319 fNewPolarization = fOldPolarization; 319 fNewPolarization = fOldPolarization;
320 320
321 aParticleChange.ProposeTrackStatus(fStopAndK 321 aParticleChange.ProposeTrackStatus(fStopAndKill);
322 } 322 }
323 323
324 inline void G4OpBoundaryProcess::DoReflection( 324 inline void G4OpBoundaryProcess::DoReflection()
325 { 325 {
326 if(fStatus == LambertianReflection) 326 if(fStatus == LambertianReflection)
327 { 327 {
328 fNewMomentum = G4LambertianRand(fGlobalNor 328 fNewMomentum = G4LambertianRand(fGlobalNormal);
329 fFacetNormal = (fNewMomentum - fOldMomentu 329 fFacetNormal = (fNewMomentum - fOldMomentum).unit();
330 } 330 }
331 else if(fFinish == ground) 331 else if(fFinish == ground)
332 { 332 {
333 fStatus = LobeReflection; 333 fStatus = LobeReflection;
334 if(!fRealRIndexMPV || !fImagRIndexMPV) 334 if(!fRealRIndexMPV || !fImagRIndexMPV)
335 { 335 {
336 fFacetNormal = GetFacetNormal(fOldMoment 336 fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
337 } 337 }
338 // else 338 // else
339 // complex ref. index to be implemented 339 // complex ref. index to be implemented
340 fNewMomentum = 340 fNewMomentum =
341 fOldMomentum - (2. * fOldMomentum * fFac 341 fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
342 } 342 }
343 else 343 else
344 { 344 {
345 fStatus = SpikeReflection; 345 fStatus = SpikeReflection;
346 fFacetNormal = fGlobalNormal; 346 fFacetNormal = fGlobalNormal;
347 fNewMomentum = 347 fNewMomentum =
348 fOldMomentum - (2. * fOldMomentum * fFac 348 fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
349 } 349 }
350 fNewPolarization = 350 fNewPolarization =
351 -fOldPolarization + (2. * fOldPolarization 351 -fOldPolarization + (2. * fOldPolarization * fFacetNormal * fFacetNormal);
352 } 352 }
353 353
354 #endif /* G4OpBoundaryProcess_h */ 354 #endif /* G4OpBoundaryProcess_h */
355 355