| 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" <<
68 #include "G4OpticalSurface.hh" <<
69 #include "G4RandomTools.hh" 67 #include "G4RandomTools.hh"
70 #include "G4VDiscreteProcess.hh" 68 #include "G4VDiscreteProcess.hh"
>> 69 #include "G4OpticalSurface.hh"
>> 70 #include "G4OpticalPhoton.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, <<
115 CoatedDielectricRefraction, <<
116 CoatedDielectricFrustratedTransmission <<
117 }; 114 };
118 115
119 class G4OpBoundaryProcess : public G4VDiscrete 116 class G4OpBoundaryProcess : public G4VDiscreteProcess
120 { 117 {
121 public: 118 public:
122 explicit G4OpBoundaryProcess(const G4String& 119 explicit G4OpBoundaryProcess(const G4String& processName = "OpBoundary",
123 G4ProcessType t 120 G4ProcessType type = fOptical);
124 virtual ~G4OpBoundaryProcess(); 121 virtual ~G4OpBoundaryProcess();
125 122
126 virtual G4bool IsApplicable( 123 virtual G4bool IsApplicable(
127 const G4ParticleDefinition& aParticleType) 124 const G4ParticleDefinition& aParticleType) override;
128 // Returns true -> 'is applicable' only for 125 // Returns true -> 'is applicable' only for an optical photon.
129 126
130 virtual G4double GetMeanFreePath(const G4Tra 127 virtual G4double GetMeanFreePath(const G4Track&, G4double,
131 G4ForceCond 128 G4ForceCondition* condition) override;
132 // Returns infinity; i. e. the process does 129 // Returns infinity; i. e. the process does not limit the step, but sets the
133 // 'Forced' condition for the DoIt to be inv 130 // 'Forced' condition for the DoIt to be invoked at every step. However, only
134 // at a boundary will any action be taken. 131 // at a boundary will any action be taken.
135 132
136 G4VParticleChange* PostStepDoIt(const G4Trac 133 G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
137 const G4Step 134 const G4Step& aStep) override;
138 // This is the method implementing boundary 135 // This is the method implementing boundary processes.
139 136
140 virtual G4OpBoundaryProcessStatus GetStatus( 137 virtual G4OpBoundaryProcessStatus GetStatus() const;
141 // Returns the current status. 138 // Returns the current status.
142 139
143 virtual void SetInvokeSD(G4bool); 140 virtual void SetInvokeSD(G4bool);
144 // Set flag for call to InvokeSD method. 141 // Set flag for call to InvokeSD method.
145 142
146 virtual void PreparePhysicsTable(const G4Par 143 virtual void PreparePhysicsTable(const G4ParticleDefinition&) override;
147 144
148 virtual void Initialise(); 145 virtual void Initialise();
149 146
150 void SetVerboseLevel(G4int); <<
151 <<
152 private: 147 private:
153 G4OpBoundaryProcess(const G4OpBoundaryProces 148 G4OpBoundaryProcess(const G4OpBoundaryProcess& right) = delete;
154 G4OpBoundaryProcess& operator=(const G4OpBou 149 G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess& right) = delete;
155 150
156 G4bool G4BooleanRand(const G4double prob) co 151 G4bool G4BooleanRand(const G4double prob) const;
157 152
158 G4ThreeVector GetFacetNormal(const G4ThreeVe 153 G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum,
159 const G4ThreeVe 154 const G4ThreeVector& Normal) const;
160 155
161 void DielectricMetal(); 156 void DielectricMetal();
162 void DielectricDielectric(); 157 void DielectricDielectric();
163 158
164 void DielectricLUT(); 159 void DielectricLUT();
165 void DielectricLUTDAVIS(); 160 void DielectricLUTDAVIS();
166 161
167 void DielectricDichroic(); 162 void DielectricDichroic();
168 void CoatedDielectricDielectric(); <<
169 163
170 void ChooseReflection(); 164 void ChooseReflection();
171 void DoAbsorption(); 165 void DoAbsorption();
172 void DoReflection(); 166 void DoReflection();
173 167
174 G4double GetIncidentAngle(); 168 G4double GetIncidentAngle();
175 // Returns the incident angle of optical pho 169 // Returns the incident angle of optical photon
176 170
177 G4double GetReflectivity(G4double E1_perp, G 171 G4double GetReflectivity(G4double E1_perp, G4double E1_parl,
178 G4double incidentan 172 G4double incidentangle, G4double RealRindex,
179 G4double ImaginaryR 173 G4double ImaginaryRindex);
180 // Returns the Reflectivity on a metallic su << 174 // Returns the Reflectivity on a metalic surface
181 175
182 G4double GetReflectivityThroughThinLayer(G4d << 176 void CalculateReflectivity(void);
183 G4d <<
184 G4d <<
185 // Returns the Reflectivity on a coated surf <<
186 177
187 void CalculateReflectivity(); << 178 void BoundaryProcessVerbose(void) const;
188 <<
189 void BoundaryProcessVerbose() const; <<
190 179
191 // Invoke SD for post step point if the phot 180 // Invoke SD for post step point if the photon is 'detected'
192 G4bool InvokeSD(const G4Step* step); 181 G4bool InvokeSD(const G4Step* step);
193 182
194 G4ThreeVector fOldMomentum; << 183 G4double thePhotonMomentum;
195 G4ThreeVector fOldPolarization; << 184
>> 185 G4ThreeVector OldMomentum;
>> 186 G4ThreeVector OldPolarization;
196 187
197 G4ThreeVector fNewMomentum; << 188 G4ThreeVector NewMomentum;
198 G4ThreeVector fNewPolarization; << 189 G4ThreeVector NewPolarization;
199 190
200 G4ThreeVector fGlobalNormal; << 191 G4ThreeVector theGlobalNormal;
201 G4ThreeVector fFacetNormal; << 192 G4ThreeVector theFacetNormal;
202 193
203 const G4Material* fMaterial1; << 194 G4Material* Material1;
204 const G4Material* fMaterial2; << 195 G4Material* Material2;
205 196
206 G4OpticalSurface* fOpticalSurface; << 197 G4OpticalSurface* OpticalSurface;
207 198
208 G4MaterialPropertyVector* fRealRIndexMPV; 199 G4MaterialPropertyVector* fRealRIndexMPV;
209 G4MaterialPropertyVector* fImagRIndexMPV; 200 G4MaterialPropertyVector* fImagRIndexMPV;
210 G4Physics2DVector* fDichroicVector; <<
211 201
212 G4double fPhotonMomentum; << 202 G4double Rindex1;
213 G4double fRindex1; << 203 G4double Rindex2;
214 G4double fRindex2; << 204
>> 205 G4double cost1, cost2, sint1, sint2;
>> 206
>> 207 G4OpBoundaryProcessStatus theStatus;
215 208
216 G4double fSint1; << 209 G4OpticalSurfaceModel theModel;
217 210
218 G4double fReflectivity; << 211 G4OpticalSurfaceFinish theFinish;
219 G4double fEfficiency; <<
220 G4double fTransmittance; <<
221 G4double fSurfaceRoughness; <<
222 212
223 G4double fProb_sl, fProb_ss, fProb_bs; << 213 G4double theReflectivity;
224 G4double fCarTolerance; << 214 G4double theEfficiency;
>> 215 G4double theTransmittance;
225 216
226 // Used by CoatedDielectricDielectric() << 217 G4double theSurfaceRoughness;
227 G4double fCoatedRindex, fCoatedThickness; <<
228 218
229 G4OpBoundaryProcessStatus fStatus; << 219 G4double prob_sl, prob_ss, prob_bs;
230 G4OpticalSurfaceModel fModel; <<
231 G4OpticalSurfaceFinish fFinish; <<
232 220
233 G4int f_iTE, f_iTM; << 221 G4int iTE, iTM;
234 222
235 G4int fNumSmallStepWarnings = 0; // number o << 223 G4double kCarTolerance;
236 G4int fNumBdryTypeWarnings = 0; // number o << 224
>> 225 size_t idx, idy;
>> 226 G4Physics2DVector* DichroicVector;
>> 227
>> 228 G4bool fInvokeSD;
237 229
238 size_t idx_dichroicX = 0; <<
239 size_t idx_dichroicY = 0; <<
240 size_t idx_rindex1 = 0; 230 size_t idx_rindex1 = 0;
241 size_t idx_rindex_surface = 0; 231 size_t idx_rindex_surface = 0;
242 size_t idx_reflect = 0; 232 size_t idx_reflect = 0;
243 size_t idx_eff = 0; 233 size_t idx_eff = 0;
244 size_t idx_trans = 0; 234 size_t idx_trans = 0;
245 size_t idx_lobe = 0; 235 size_t idx_lobe = 0;
246 size_t idx_spike = 0; 236 size_t idx_spike = 0;
247 size_t idx_back = 0; 237 size_t idx_back = 0;
248 size_t idx_rindex2 = 0; 238 size_t idx_rindex2 = 0;
249 size_t idx_groupvel = 0; 239 size_t idx_groupvel = 0;
250 size_t idx_rrindex = 0; 240 size_t idx_rrindex = 0;
251 size_t idx_irindex = 0; 241 size_t idx_irindex = 0;
252 size_t idx_coatedrindex = 0; <<
253 <<
254 // Used by CoatedDielectricDielectric() <<
255 G4bool fCoatedFrustratedTransmission = true; <<
256 <<
257 G4bool fInvokeSD; <<
258 }; 242 };
259 243
260 //////////////////// 244 ////////////////////
261 // Inline methods 245 // Inline methods
262 //////////////////// 246 ////////////////////
263 247
264 inline G4bool G4OpBoundaryProcess::G4BooleanRa 248 inline G4bool G4OpBoundaryProcess::G4BooleanRand(const G4double prob) const
265 { 249 {
266 // Returns a random boolean variable with th << 250 /* Returns a random boolean variable with the specified probability */
267 return (G4UniformRand() < prob); 251 return (G4UniformRand() < prob);
268 } 252 }
269 253
270 inline G4bool G4OpBoundaryProcess::IsApplicabl 254 inline G4bool G4OpBoundaryProcess::IsApplicable(
271 const G4ParticleDefinition& aParticleType) 255 const G4ParticleDefinition& aParticleType)
272 { 256 {
273 return (&aParticleType == G4OpticalPhoton::O 257 return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
274 } 258 }
275 259
276 inline G4OpBoundaryProcessStatus G4OpBoundaryP 260 inline G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus() const
277 { 261 {
278 return fStatus; << 262 return theStatus;
279 } 263 }
280 264
>> 265 inline void G4OpBoundaryProcess::SetInvokeSD(G4bool flag) { fInvokeSD = flag; }
>> 266
281 inline void G4OpBoundaryProcess::ChooseReflect 267 inline void G4OpBoundaryProcess::ChooseReflection()
282 { 268 {
283 G4double rand = G4UniformRand(); 269 G4double rand = G4UniformRand();
284 if(rand < fProb_ss) << 270 if(rand >= 0.0 && rand < prob_ss)
285 { 271 {
286 fStatus = SpikeReflection; << 272 theStatus = SpikeReflection;
287 fFacetNormal = fGlobalNormal; << 273 theFacetNormal = theGlobalNormal;
288 } 274 }
289 else if(rand < fProb_ss + fProb_sl) << 275 else if(rand >= prob_ss && rand <= prob_ss + prob_sl)
290 { 276 {
291 fStatus = LobeReflection; << 277 theStatus = LobeReflection;
292 } 278 }
293 else if(rand < fProb_ss + fProb_sl + fProb_b << 279 else if(rand > prob_ss + prob_sl && rand < prob_ss + prob_sl + prob_bs)
294 { 280 {
295 fStatus = BackScattering; << 281 theStatus = BackScattering;
296 } 282 }
297 else 283 else
298 { 284 {
299 fStatus = LambertianReflection; << 285 theStatus = LambertianReflection;
300 } 286 }
301 } 287 }
302 288
303 inline void G4OpBoundaryProcess::DoAbsorption( 289 inline void G4OpBoundaryProcess::DoAbsorption()
304 { 290 {
305 fStatus = Absorption; << 291 theStatus = Absorption;
306 292
307 if(G4BooleanRand(fEfficiency)) << 293 if(G4BooleanRand(theEfficiency))
308 { 294 {
309 // EnergyDeposited =/= 0 means: photon has 295 // EnergyDeposited =/= 0 means: photon has been detected
310 fStatus = Detection; << 296 theStatus = Detection;
311 aParticleChange.ProposeLocalEnergyDeposit( << 297 aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
312 } 298 }
313 else 299 else
314 { 300 {
315 aParticleChange.ProposeLocalEnergyDeposit( 301 aParticleChange.ProposeLocalEnergyDeposit(0.0);
316 } 302 }
317 303
318 fNewMomentum = fOldMomentum; << 304 NewMomentum = OldMomentum;
319 fNewPolarization = fOldPolarization; << 305 NewPolarization = OldPolarization;
320 306
321 aParticleChange.ProposeTrackStatus(fStopAndK 307 aParticleChange.ProposeTrackStatus(fStopAndKill);
322 } 308 }
323 309
324 inline void G4OpBoundaryProcess::DoReflection( 310 inline void G4OpBoundaryProcess::DoReflection()
325 { 311 {
326 if(fStatus == LambertianReflection) << 312 if(theStatus == LambertianReflection)
327 { 313 {
328 fNewMomentum = G4LambertianRand(fGlobalNor << 314 NewMomentum = G4LambertianRand(theGlobalNormal);
329 fFacetNormal = (fNewMomentum - fOldMomentu << 315 theFacetNormal = (NewMomentum - OldMomentum).unit();
330 } 316 }
331 else if(fFinish == ground) << 317 else if(theFinish == ground)
332 { 318 {
333 fStatus = LobeReflection; << 319 theStatus = LobeReflection;
334 if(!fRealRIndexMPV || !fImagRIndexMPV) << 320 if(fRealRIndexMPV && fImagRIndexMPV)
>> 321 {
>> 322 //
>> 323 }
>> 324 else
335 { 325 {
336 fFacetNormal = GetFacetNormal(fOldMoment << 326 theFacetNormal = GetFacetNormal(OldMomentum, theGlobalNormal);
337 } 327 }
338 // else << 328 G4double PdotN = OldMomentum * theFacetNormal;
339 // complex ref. index to be implemented << 329 NewMomentum = OldMomentum - (2. * PdotN) * theFacetNormal;
340 fNewMomentum = <<
341 fOldMomentum - (2. * fOldMomentum * fFac <<
342 } 330 }
343 else 331 else
344 { 332 {
345 fStatus = SpikeReflection; << 333 theStatus = SpikeReflection;
346 fFacetNormal = fGlobalNormal; << 334 theFacetNormal = theGlobalNormal;
347 fNewMomentum = << 335 G4double PdotN = OldMomentum * theFacetNormal;
348 fOldMomentum - (2. * fOldMomentum * fFac << 336 NewMomentum = OldMomentum - (2. * PdotN) * theFacetNormal;
349 } 337 }
350 fNewPolarization = << 338 G4double EdotN = OldPolarization * theFacetNormal;
351 -fOldPolarization + (2. * fOldPolarization << 339 NewPolarization = -OldPolarization + (2. * EdotN) * theFacetNormal;
352 } 340 }
353 341
354 #endif /* G4OpBoundaryProcess_h */ 342 #endif /* G4OpBoundaryProcess_h */
355 343