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