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: G4OpBoundaryProcess.hh,v 1.8 2002/03/29 01:03:53 gum Exp $ >> 25 // GEANT4 tag $Name: geant4-05-02-patch-01 $ 27 // 26 // 28 // << 27 // 29 ////////////////////////////////////////////// 28 //////////////////////////////////////////////////////////////////////// 30 // Optical Photon Boundary Process Class Defin 29 // Optical Photon Boundary Process Class Definition 31 ////////////////////////////////////////////// 30 //////////////////////////////////////////////////////////////////////// 32 // 31 // 33 // File: G4OpBoundaryProcess.hh 32 // File: G4OpBoundaryProcess.hh 34 // Description: Discrete Process -- reflection 33 // Description: Discrete Process -- reflection/refraction at 35 // optical in 34 // optical interfaces 36 // Version: 1.1 35 // Version: 1.1 37 // Created: 1997-06-18 36 // Created: 1997-06-18 38 // Modified: 2005-07-28 add G4ProcessType t << 37 // Modified: 1999-10-29 add method and class descriptors 39 // 1999-10-29 add method and clas << 38 // 1999-10-10 - Fill NewMomentum/NewPolarization in 40 // 1999-10-10 - Fill NewMomentum/ << 41 // DoAbsorption. The 39 // DoAbsorption. These members need to be 42 // filled since DoIt << 40 // filled since DoIt calls 43 // aParticleChange.S 41 // aParticleChange.SetMomentumChange etc. 44 // upon return (than 42 // upon return (thanks to: Clark McGrew) 45 // 2006-11-04 - add capability of << 46 // off a metal surfa << 47 // of refraction - T << 48 // Hauptman (Dept. o << 49 // 2009-11-10 - add capability of << 50 // with Look-Up-Tabl << 51 // optical reflectan << 52 // treatments - Than << 53 // William Moses (La << 54 // 2013-06-01 - add the capabilit << 55 // of a dichronic fi << 56 // 2017-02-24 - add capability of << 57 // with Look-Up-Tabl << 58 // 43 // 59 // Author: Peter Gumplinger 44 // Author: Peter Gumplinger 60 // adopted from work by Werner Ke 45 // adopted from work by Werner Keil - April 2/96 >> 46 // mail: gum@triumf.ca 61 // 47 // >> 48 // CVS version tag: 62 ////////////////////////////////////////////// 49 //////////////////////////////////////////////////////////////////////// 63 50 64 #ifndef G4OpBoundaryProcess_h 51 #ifndef G4OpBoundaryProcess_h 65 #define G4OpBoundaryProcess_h 1 52 #define G4OpBoundaryProcess_h 1 66 53 67 #include "G4OpticalPhoton.hh" << 54 ///////////// 68 #include "G4OpticalSurface.hh" << 55 // Includes 69 #include "G4RandomTools.hh" << 56 ///////////// >> 57 >> 58 #include "globals.hh" >> 59 #include "templates.hh" >> 60 #include "geomdefs.hh" >> 61 #include "Randomize.hh" >> 62 #include "G4Step.hh" 70 #include "G4VDiscreteProcess.hh" 63 #include "G4VDiscreteProcess.hh" >> 64 #include "G4DynamicParticle.hh" >> 65 #include "G4Material.hh" >> 66 #include "G4LogicalBorderSurface.hh" >> 67 #include "G4LogicalSkinSurface.hh" >> 68 #include "G4OpticalSurface.hh" >> 69 #include "G4OpticalPhoton.hh" >> 70 #include "G4TransportationManager.hh" 71 71 72 enum G4OpBoundaryProcessStatus << 72 // Class Description: 73 { << 73 // Discrete Process -- reflection/refraction at optical interfaces. 74 Undefined, << 74 // Class inherits publicly from G4VDiscreteProcess. 75 Transmission, << 75 // Class Description - End: 76 FresnelRefraction, << 76 77 FresnelReflection, << 77 ///////////////////// 78 TotalInternalReflection, << 78 // Class Definition 79 LambertianReflection, << 79 ///////////////////// 80 LobeReflection, << 80 81 SpikeReflection, << 81 enum G4OpBoundaryProcessStatus { Undefined, 82 BackScattering, << 82 FresnelRefraction, FresnelReflection, 83 Absorption, << 83 TotalInternalReflection, 84 Detection, << 84 LambertianReflection, LobeReflection, 85 NotAtBoundary, << 85 SpikeReflection, BackScattering, 86 SameMaterial, << 86 Absorption, Detection }; 87 StepTooSmall, << 88 NoRINDEX, << 89 PolishedLumirrorAirReflection, << 90 PolishedLumirrorGlueReflection, << 91 PolishedAirReflection, << 92 PolishedTeflonAirReflection, << 93 PolishedTiOAirReflection, << 94 PolishedTyvekAirReflection, << 95 PolishedVM2000AirReflection, << 96 PolishedVM2000GlueReflection, << 97 EtchedLumirrorAirReflection, << 98 EtchedLumirrorGlueReflection, << 99 EtchedAirReflection, << 100 EtchedTeflonAirReflection, << 101 EtchedTiOAirReflection, << 102 EtchedTyvekAirReflection, << 103 EtchedVM2000AirReflection, << 104 EtchedVM2000GlueReflection, << 105 GroundLumirrorAirReflection, << 106 GroundLumirrorGlueReflection, << 107 GroundAirReflection, << 108 GroundTeflonAirReflection, << 109 GroundTiOAirReflection, << 110 GroundTyvekAirReflection, << 111 GroundVM2000AirReflection, << 112 GroundVM2000GlueReflection, << 113 Dichroic, << 114 CoatedDielectricReflection, << 115 CoatedDielectricRefraction, << 116 CoatedDielectricFrustratedTransmission << 117 }; << 118 87 119 class G4OpBoundaryProcess : public G4VDiscrete << 88 class G4OpBoundaryProcess : public G4VDiscreteProcess 120 { 89 { 121 public: << 122 explicit G4OpBoundaryProcess(const G4String& << 123 G4ProcessType t << 124 virtual ~G4OpBoundaryProcess(); << 125 90 126 virtual G4bool IsApplicable( << 91 private: 127 const G4ParticleDefinition& aParticleType) << 92 128 // Returns true -> 'is applicable' only for << 93 ////////////// >> 94 // Operators >> 95 ////////////// >> 96 >> 97 // G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess &right); 129 98 130 virtual G4double GetMeanFreePath(const G4Tra << 99 // G4OpBoundaryProcess(const G4OpBoundaryProcess &right); 131 G4ForceCond << 132 // Returns infinity; i. e. the process does << 133 // 'Forced' condition for the DoIt to be inv << 134 // at a boundary will any action be taken. << 135 100 136 G4VParticleChange* PostStepDoIt(const G4Trac << 101 public: // Without description 137 const G4Step << 138 // This is the method implementing boundary << 139 102 140 virtual G4OpBoundaryProcessStatus GetStatus( << 103 //////////////////////////////// 141 // Returns the current status. << 104 // Constructors and Destructor >> 105 //////////////////////////////// 142 106 143 virtual void SetInvokeSD(G4bool); << 107 G4OpBoundaryProcess(const G4String& processName = "OpBoundary"); 144 // Set flag for call to InvokeSD method. << 145 108 146 virtual void PreparePhysicsTable(const G4Par << 109 ~G4OpBoundaryProcess(); 147 110 148 virtual void Initialise(); << 111 //////////// >> 112 // Methods >> 113 //////////// 149 114 150 void SetVerboseLevel(G4int); << 115 public: // With description 151 116 152 private: << 117 G4bool IsApplicable(const G4ParticleDefinition& aParticleType); 153 G4OpBoundaryProcess(const G4OpBoundaryProces << 118 // Returns true -> 'is applicable' only for an optical photon. 154 G4OpBoundaryProcess& operator=(const G4OpBou << 155 119 156 G4bool G4BooleanRand(const G4double prob) co << 120 G4double GetMeanFreePath(const G4Track& , >> 121 G4double , >> 122 G4ForceCondition* condition); >> 123 // Returns infinity; i. e. the process does not limit the step, >> 124 // but sets the 'Forced' condition for the DoIt to be invoked at >> 125 // every step. However, only at a boundary will any action be >> 126 // taken. 157 127 158 G4ThreeVector GetFacetNormal(const G4ThreeVe << 128 G4VParticleChange* PostStepDoIt(const G4Track& aTrack, 159 const G4ThreeVe << 129 const G4Step& aStep); >> 130 // This is the method implementing boundary processes. 160 131 161 void DielectricMetal(); << 132 G4OpticalSurfaceModel GetModel() const; 162 void DielectricDielectric(); << 133 // Returns the optical surface mode. 163 134 164 void DielectricLUT(); << 135 G4OpBoundaryProcessStatus GetStatus() const; 165 void DielectricLUTDAVIS(); << 136 // Returns the current status. 166 137 167 void DielectricDichroic(); << 138 void SetModel(G4OpticalSurfaceModel model); 168 void CoatedDielectricDielectric(); << 139 // Set the optical surface model to be followed >> 140 // (glisur || unified). 169 141 170 void ChooseReflection(); << 142 private: 171 void DoAbsorption(); << 172 void DoReflection(); << 173 143 174 G4double GetIncidentAngle(); << 144 void G4Swap(G4double* a, G4double* b) const; 175 // Returns the incident angle of optical pho << 176 145 177 G4double GetReflectivity(G4double E1_perp, G << 146 void G4Swap(G4Material* a, G4Material* b) const; 178 G4double incidentan << 179 G4double ImaginaryR << 180 // Returns the Reflectivity on a metallic su << 181 147 182 G4double GetReflectivityThroughThinLayer(G4d << 148 void G4VectorSwap(G4ThreeVector* vec1, G4ThreeVector* vec2) const; 183 G4d << 184 G4d << 185 // Returns the Reflectivity on a coated surf << 186 149 187 void CalculateReflectivity(); << 150 G4bool G4BooleanRand(const G4double prob) const; 188 151 189 void BoundaryProcessVerbose() const; << 152 G4ThreeVector G4IsotropicRand() const; 190 153 191 // Invoke SD for post step point if the phot << 154 G4ThreeVector G4LambertianRand(const G4ThreeVector& normal); 192 G4bool InvokeSD(const G4Step* step); << 193 155 194 G4ThreeVector fOldMomentum; << 156 G4ThreeVector G4PlaneVectorRand(const G4ThreeVector& normal) const; 195 G4ThreeVector fOldPolarization; << 196 157 197 G4ThreeVector fNewMomentum; << 158 G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum, 198 G4ThreeVector fNewPolarization; << 159 const G4ThreeVector& Normal) const; 199 160 200 G4ThreeVector fGlobalNormal; << 161 void DielectricMetal(); 201 G4ThreeVector fFacetNormal; << 162 void DielectricDielectric(); 202 163 203 const G4Material* fMaterial1; << 164 void ChooseReflection(); 204 const G4Material* fMaterial2; << 165 void DoAbsorption(); >> 166 void DoReflection(); 205 167 206 G4OpticalSurface* fOpticalSurface; << 168 private: 207 169 208 G4MaterialPropertyVector* fRealRIndexMPV; << 170 G4double thePhotonMomentum; 209 G4MaterialPropertyVector* fImagRIndexMPV; << 210 G4Physics2DVector* fDichroicVector; << 211 171 212 G4double fPhotonMomentum; << 172 G4ThreeVector OldMomentum; 213 G4double fRindex1; << 173 G4ThreeVector OldPolarization; 214 G4double fRindex2; << 215 174 216 G4double fSint1; << 175 G4ThreeVector NewMomentum; >> 176 G4ThreeVector NewPolarization; 217 177 218 G4double fReflectivity; << 178 G4ThreeVector theGlobalNormal; 219 G4double fEfficiency; << 179 G4ThreeVector theFacetNormal; 220 G4double fTransmittance; << 221 G4double fSurfaceRoughness; << 222 180 223 G4double fProb_sl, fProb_ss, fProb_bs; << 181 G4Material* Material1; 224 G4double fCarTolerance; << 182 G4Material* Material2; 225 183 226 // Used by CoatedDielectricDielectric() << 184 G4OpticalSurface* OpticalSurface; 227 G4double fCoatedRindex, fCoatedThickness; << 228 185 229 G4OpBoundaryProcessStatus fStatus; << 186 G4double Rindex1; 230 G4OpticalSurfaceModel fModel; << 187 G4double Rindex2; 231 G4OpticalSurfaceFinish fFinish; << 232 188 233 G4int f_iTE, f_iTM; << 189 G4double cost1, cost2, sint1, sint2; 234 190 235 G4int fNumSmallStepWarnings = 0; // number o << 191 G4OpBoundaryProcessStatus theStatus; 236 G4int fNumBdryTypeWarnings = 0; // number o << 237 192 238 size_t idx_dichroicX = 0; << 193 G4OpticalSurfaceModel theModel; 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 194 254 // Used by CoatedDielectricDielectric() << 195 G4OpticalSurfaceFinish theFinish; 255 G4bool fCoatedFrustratedTransmission = true; << 196 >> 197 G4double theReflectivity; >> 198 G4double theEfficiency; >> 199 G4double prob_sl, prob_ss, prob_bs; 256 200 257 G4bool fInvokeSD; << 258 }; 201 }; 259 202 260 //////////////////// 203 //////////////////// 261 // Inline methods 204 // Inline methods 262 //////////////////// 205 //////////////////// 263 206 264 inline G4bool G4OpBoundaryProcess::G4BooleanRa << 207 inline >> 208 void G4OpBoundaryProcess::G4Swap(G4double* a, G4double* b) const >> 209 { >> 210 // swaps the contents of the objects pointed >> 211 // to by 'a' and 'b'! >> 212 >> 213 G4double temp; >> 214 >> 215 temp = *a; >> 216 *a = *b; >> 217 *b = temp; >> 218 } >> 219 >> 220 inline >> 221 void G4OpBoundaryProcess::G4Swap(G4Material* a, G4Material* b) const >> 222 { >> 223 // ONLY swaps the pointers; i.e. what used to be pointed >> 224 // to by 'a' is now pointed to by 'b' and vice versa! >> 225 >> 226 G4Material* temp = a; >> 227 >> 228 a = b; >> 229 b = temp; >> 230 } >> 231 >> 232 inline >> 233 void G4OpBoundaryProcess::G4VectorSwap(G4ThreeVector* vec1, >> 234 G4ThreeVector* vec2) const 265 { 235 { 266 // Returns a random boolean variable with th << 236 // swaps the contents of the objects pointed >> 237 // to by 'vec1' and 'vec2'! >> 238 >> 239 G4ThreeVector temp; >> 240 >> 241 temp = *vec1; >> 242 *vec1 = *vec2; >> 243 *vec2 = temp; >> 244 } >> 245 >> 246 inline >> 247 G4bool G4OpBoundaryProcess::G4BooleanRand(const G4double prob) const >> 248 { >> 249 /* Returns a random boolean variable with the specified probability */ >> 250 267 return (G4UniformRand() < prob); 251 return (G4UniformRand() < prob); 268 } 252 } 269 253 270 inline G4bool G4OpBoundaryProcess::IsApplicabl << 254 inline 271 const G4ParticleDefinition& aParticleType) << 255 G4ThreeVector G4OpBoundaryProcess::G4IsotropicRand() const 272 { 256 { 273 return (&aParticleType == G4OpticalPhoton::O << 257 /* Returns a random isotropic unit vector. */ >> 258 >> 259 G4ThreeVector vect; >> 260 G4double len2; >> 261 >> 262 do { >> 263 >> 264 vect.setX(G4UniformRand() - 0.5); >> 265 vect.setY(G4UniformRand() - 0.5); >> 266 vect.setZ(G4UniformRand() - 0.5); >> 267 >> 268 len2 = vect.mag2(); >> 269 >> 270 } while (len2 < 0.01 || len2 > 0.25); >> 271 >> 272 return vect.unit(); 274 } 273 } 275 274 276 inline G4OpBoundaryProcessStatus G4OpBoundaryP << 275 inline >> 276 G4ThreeVector G4OpBoundaryProcess:: >> 277 G4LambertianRand(const G4ThreeVector& normal) 277 { 278 { 278 return fStatus; << 279 /* Returns a random lambertian unit vector. */ 279 } << 280 280 << 281 G4ThreeVector vect; 281 inline void G4OpBoundaryProcess::ChooseReflect << 282 G4double ndotv; 282 { << 283 283 G4double rand = G4UniformRand(); << 284 do { 284 if(rand < fProb_ss) << 285 vect = G4IsotropicRand(); 285 { << 286 286 fStatus = SpikeReflection; << 287 ndotv = normal * vect; 287 fFacetNormal = fGlobalNormal; << 288 288 } << 289 if (ndotv < 0.0) { 289 else if(rand < fProb_ss + fProb_sl) << 290 vect = -vect; 290 { << 291 ndotv = -ndotv; 291 fStatus = LobeReflection; << 292 } << 293 else if(rand < fProb_ss + fProb_sl + fProb_b << 294 { << 295 fStatus = BackScattering; << 296 } << 297 else << 298 { << 299 fStatus = LambertianReflection; << 300 } << 301 } << 302 << 303 inline void G4OpBoundaryProcess::DoAbsorption( << 304 { << 305 fStatus = Absorption; << 306 << 307 if(G4BooleanRand(fEfficiency)) << 308 { << 309 // EnergyDeposited =/= 0 means: photon has << 310 fStatus = Detection; << 311 aParticleChange.ProposeLocalEnergyDeposit( << 312 } << 313 else << 314 { << 315 aParticleChange.ProposeLocalEnergyDeposit( << 316 } << 317 << 318 fNewMomentum = fOldMomentum; << 319 fNewPolarization = fOldPolarization; << 320 << 321 aParticleChange.ProposeTrackStatus(fStopAndK << 322 } << 323 << 324 inline void G4OpBoundaryProcess::DoReflection( << 325 { << 326 if(fStatus == LambertianReflection) << 327 { << 328 fNewMomentum = G4LambertianRand(fGlobalNor << 329 fFacetNormal = (fNewMomentum - fOldMomentu << 330 } << 331 else if(fFinish == ground) << 332 { << 333 fStatus = LobeReflection; << 334 if(!fRealRIndexMPV || !fImagRIndexMPV) << 335 { << 336 fFacetNormal = GetFacetNormal(fOldMoment << 337 } 292 } 338 // else << 293 339 // complex ref. index to be implemented << 294 } while (!G4BooleanRand(ndotv)); 340 fNewMomentum = << 295 return vect; 341 fOldMomentum - (2. * fOldMomentum * fFac << 296 } 342 } << 297 343 else << 298 inline 344 { << 299 G4ThreeVector G4OpBoundaryProcess:: 345 fStatus = SpikeReflection; << 300 G4PlaneVectorRand(const G4ThreeVector& normal) const 346 fFacetNormal = fGlobalNormal; << 301 347 fNewMomentum = << 302 /* This function chooses a random vector within a plane given 348 fOldMomentum - (2. * fOldMomentum * fFac << 303 by the unit normal */ 349 } << 304 { 350 fNewPolarization = << 305 G4ThreeVector vec1 = normal.orthogonal(); 351 -fOldPolarization + (2. * fOldPolarization << 306 >> 307 G4ThreeVector vec2 = vec1.cross(normal); >> 308 >> 309 G4double cost = 2.*G4UniformRand() - 1.0; >> 310 G4double sint = sqrt(1.0 - cost * cost); >> 311 >> 312 return cost * vec1 + sint * vec2; >> 313 } >> 314 >> 315 inline >> 316 G4bool G4OpBoundaryProcess::IsApplicable(const G4ParticleDefinition& >> 317 aParticleType) >> 318 { >> 319 return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() ); >> 320 } >> 321 >> 322 inline >> 323 G4OpticalSurfaceModel G4OpBoundaryProcess::GetModel() const >> 324 { >> 325 return theModel; >> 326 } >> 327 >> 328 inline >> 329 G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus() const >> 330 { >> 331 return theStatus; >> 332 } >> 333 >> 334 inline >> 335 void G4OpBoundaryProcess::SetModel(G4OpticalSurfaceModel model) >> 336 { >> 337 theModel = model; >> 338 } >> 339 >> 340 inline >> 341 void G4OpBoundaryProcess::ChooseReflection() >> 342 { >> 343 G4double rand = G4UniformRand(); >> 344 if ( rand >= 0.0 && rand < prob_ss ) { >> 345 theStatus = SpikeReflection; >> 346 theFacetNormal = theGlobalNormal; >> 347 } >> 348 else if ( rand >= prob_ss && >> 349 rand <= prob_ss+prob_sl) { >> 350 theStatus = LobeReflection; >> 351 } >> 352 else if ( rand > prob_ss+prob_sl && >> 353 rand < prob_ss+prob_sl+prob_bs ) { >> 354 theStatus = BackScattering; >> 355 } >> 356 else { >> 357 theStatus = LambertianReflection; >> 358 } >> 359 } >> 360 >> 361 inline >> 362 void G4OpBoundaryProcess::DoAbsorption() >> 363 { >> 364 theStatus = Absorption; >> 365 >> 366 if ( G4BooleanRand(theEfficiency) ) { >> 367 // EnergyDeposited =/= 0 means: photon has been detected >> 368 theStatus = Detection; >> 369 aParticleChange.SetLocalEnergyDeposit(thePhotonMomentum); >> 370 } >> 371 else { >> 372 aParticleChange.SetLocalEnergyDeposit(0.0); >> 373 } >> 374 >> 375 NewMomentum = OldMomentum; >> 376 NewPolarization = OldPolarization; >> 377 >> 378 // aParticleChange.SetEnergyChange(0.0); >> 379 aParticleChange.SetStatusChange(fStopAndKill); >> 380 } >> 381 >> 382 inline >> 383 void G4OpBoundaryProcess::DoReflection() >> 384 { >> 385 if ( theStatus == LambertianReflection ) { >> 386 >> 387 NewMomentum = G4LambertianRand(theGlobalNormal); >> 388 theFacetNormal = (NewMomentum - OldMomentum).unit(); >> 389 >> 390 } >> 391 else if ( theFinish == ground ) { >> 392 >> 393 theStatus = LobeReflection; >> 394 theFacetNormal = GetFacetNormal(OldMomentum,theGlobalNormal); >> 395 G4double PdotN = OldMomentum * theFacetNormal; >> 396 NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal; >> 397 >> 398 } >> 399 else { >> 400 >> 401 theStatus = SpikeReflection; >> 402 theFacetNormal = theGlobalNormal; >> 403 G4double PdotN = OldMomentum * theFacetNormal; >> 404 NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal; >> 405 >> 406 } >> 407 G4double EdotN = OldPolarization * theFacetNormal; >> 408 NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal; 352 } 409 } 353 410 354 #endif /* G4OpBoundaryProcess_h */ 411 #endif /* G4OpBoundaryProcess_h */ 355 412