Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/optical/include/G4OpBoundaryProcess.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/optical/include/G4OpBoundaryProcess.hh (Version 11.3.0) and /processes/optical/include/G4OpBoundaryProcess.hh (Version 9.2.p1)


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