Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/materials/include/G4OpticalSurface.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 /materials/include/G4OpticalSurface.hh (Version 11.3.0) and /materials/include/G4OpticalSurface.hh (Version 6.0)


  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 //
                                                   >>  23 //
                                                   >>  24 // $Id: G4OpticalSurface.hh,v 1.7 2003/12/01 15:13:41 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-06-00 $
                                                   >>  26 //
                                                   >>  27 // 
 26 //////////////////////////////////////////////     28 ////////////////////////////////////////////////////////////////////////
 27 // G4OpticalSurface Definition                     29 // G4OpticalSurface Definition
 28 //////////////////////////////////////////////     30 ////////////////////////////////////////////////////////////////////////
 29 //                                                 31 //
 30 // File:        G4OpticalSurface.hh                32 // File:        G4OpticalSurface.hh
 31 // Description: A optical surface class for us     33 // Description: A optical surface class for use in G4OpBoundaryProcess
 32 // Version:     2.0                                34 // Version:     2.0
 33 // Created:     1997-06-26                         35 // Created:     1997-06-26
 34 // Author:      Peter Gumplinger                   36 // Author:      Peter Gumplinger
 35 // Updated:     1999-10-29 add method and clas     37 // Updated:     1999-10-29 add method and class descriptors
 36 //              2017-02-24 Mariele Stockhoff a <<  38 // mail:        gum@triumf.ca
 37 //                                                 39 //
 38 // Class Description:                          << 
 39 // A optical surface class for use in the G4Op << 
 40 // Contains the enumerations: G4OpticalSurface << 
 41 // and G4OpticalSurfaceModel.                  << 
 42 //////////////////////////////////////////////     40 ////////////////////////////////////////////////////////////////////////
 43                                                    41 
 44 #ifndef G4OpticalSurface_h                         42 #ifndef G4OpticalSurface_h
 45 #define G4OpticalSurface_h 1                       43 #define G4OpticalSurface_h 1
 46                                                    44 
 47 #include "G4Physics2DVector.hh"                <<  45 /////////////
 48 #include "G4SurfaceProperty.hh"                <<  46 // Includes
                                                   >>  47 /////////////
                                                   >>  48 
 49 #include "G4Types.hh"                              49 #include "G4Types.hh"
                                                   >>  50 #include "G4SurfaceProperty.hh"
                                                   >>  51 
                                                   >>  52 // Class Description:
                                                   >>  53 // A optical surface class for use in the G4OpBoundaryProcess class.
                                                   >>  54 // Contains the enumerations: G4OpticalSurfaceFinish, G4OpticalSurfaceType,
                                                   >>  55 // and G4OpticalSurfaceModel.
                                                   >>  56 // Class Description - End:
 50                                                    57 
 51 // clang-format off                            << 
 52 enum G4OpticalSurfaceFinish                        58 enum G4OpticalSurfaceFinish
 53 {                                                  59 {
 54   polished,              // smooth perfectly p <<  60    polished,                    // smooth perfectly polished surface
 55   polishedfrontpainted,  // smooth top-layer ( <<  61    polishedfrontpainted,        // smooth top-layer (front) paint
 56   polishedbackpainted,   // same is 'polished' <<  62    polishedbackpainted,         // same is 'polished' but with a back-paint
 57                                                <<  63    ground,                      // rough surface
 58   ground,              // rough surface        <<  64    groundfrontpainted,          // rough top-layer (front) paint
 59   groundfrontpainted,  // rough top-layer (fro <<  65    groundbackpainted            // same as 'ground' but with a back-paint
 60   groundbackpainted,   // same as 'ground' but << 
 61                                                << 
 62   // for LBNL LUT model                        << 
 63   polishedlumirrorair,   // mechanically polis << 
 64   polishedlumirrorglue,  // mechanically polis << 
 65                          // meltmount          << 
 66   polishedair,           // mechanically polis << 
 67   polishedteflonair,     // mechanically polis << 
 68   polishedtioair,        // mechanically polis << 
 69   polishedtyvekair,      // mechanically polis << 
 70   polishedvm2000air,     // mechanically polis << 
 71   polishedvm2000glue,    // mechanically polis << 
 72                          // meltmount          << 
 73                                                << 
 74   etchedlumirrorair,   // chemically etched su << 
 75   etchedlumirrorglue,  // chemically etched su << 
 76   etchedair,           // chemically etched su << 
 77   etchedteflonair,     // chemically etched su << 
 78   etchedtioair,        // chemically etched su << 
 79   etchedtyvekair,      // chemically etched su << 
 80   etchedvm2000air,     // chemically etched su << 
 81   etchedvm2000glue,    // chemically etched su << 
 82                                                << 
 83   groundlumirrorair,   // rough-cut surface, w << 
 84   groundlumirrorglue,  // rough-cut surface, w << 
 85   groundair,           // rough-cut surface    << 
 86   groundteflonair,     // rough-cut surface, w << 
 87   groundtioair,        // rough-cut surface, w << 
 88   groundtyvekair,      // rough-cut surface, w << 
 89   groundvm2000air,     // rough-cut surface, w << 
 90   groundvm2000glue,    // rough-cut surface, w << 
 91                                                << 
 92   // for DAVIS model                           << 
 93   Rough_LUT,              // rough surface     << 
 94   RoughTeflon_LUT,        // rough surface wra << 
 95   RoughESR_LUT,           // rough surface wra << 
 96   RoughESRGrease_LUT,     // rough surface wra << 
 97                           // and coupled with  << 
 98   Polished_LUT,           // polished surface  << 
 99   PolishedTeflon_LUT,     // polished surface  << 
100   PolishedESR_LUT,        // polished surface  << 
101   PolishedESRGrease_LUT,  // polished surface  << 
102                           // and coupled with  << 
103   Detector_LUT            // polished surface  << 
104 };                                                 66 };
105                                                    67 
106 enum G4OpticalSurfaceModel                         68 enum G4OpticalSurfaceModel
107 {                                                  69 {
108   glisur,   // original GEANT3 model           <<  70    glisur,                      // original GEANT3 model
109   unified,  // UNIFIED model                   <<  71    unified                      // UNIFIED model
110   LUT,      // Look-Up-Table model (LBNL model << 
111   DAVIS,    // DAVIS model                     << 
112   dichroic  // dichroic filter                 << 
113 };                                                 72 };
114                                                    73 
115 // clang-format on                             << 
116                                                << 
117 class G4MaterialPropertiesTable;                   74 class G4MaterialPropertiesTable;
118                                                    75 
                                                   >>  76 /////////////////////
                                                   >>  77 // Class Definition
                                                   >>  78 /////////////////////
                                                   >>  79 
119 class G4OpticalSurface : public G4SurfacePrope     80 class G4OpticalSurface : public G4SurfaceProperty
120 {                                                  81 {
121  public:                                       << 
122   // Constructor of an optical surface object. << 
123   G4OpticalSurface(const G4String& name, G4Opt << 
124     G4OpticalSurfaceFinish finish = polished,  << 
125     G4double value = 1.0);                     << 
126                                                << 
127   ~G4OpticalSurface() override;                << 
128                                                << 
129   G4OpticalSurface(const G4OpticalSurface& rig << 
130   G4OpticalSurface& operator=(const G4OpticalS << 
131                                                << 
132   G4bool operator==(const G4OpticalSurface& ri << 
133   G4bool operator!=(const G4OpticalSurface& ri << 
134                                                << 
135   void SetType(const G4SurfaceType& type) over << 
136                                                << 
137   // Returns the optical surface finish.       << 
138   inline G4OpticalSurfaceFinish GetFinish() co << 
139                                                << 
140   // Sets the optical surface finish.          << 
141   void SetFinish(const G4OpticalSurfaceFinish) << 
142                                                << 
143   // Returns the optical surface model used.   << 
144   inline G4OpticalSurfaceModel GetModel() cons << 
145                                                << 
146   // Sets the optical surface model to be foll << 
147   inline void SetModel(const G4OpticalSurfaceM << 
148                                                << 
149   // Returns an unified model surface paramete << 
150   inline G4double GetSigmaAlpha() const { retu << 
151                                                << 
152   // Sets an unified model surface parameter.  << 
153   inline void SetSigmaAlpha(const G4double s_a << 
154                                                    82 
155   // Returns the optical surface polish type.  <<  83 public: // Without description
156   G4double GetPolish() const { return polish;  <<  84   
                                                   >>  85         //////////////
                                                   >>  86         // Operators
                                                   >>  87         //////////////
                                                   >>  88   
                                                   >>  89   G4OpticalSurface(const G4OpticalSurface &right);
                                                   >>  90   const G4OpticalSurface & operator=(const G4OpticalSurface &right);
                                                   >>  91   
                                                   >>  92   G4int operator==(const G4OpticalSurface &right) const;
                                                   >>  93   G4int operator!=(const G4OpticalSurface &right) const;
                                                   >>  94 
                                                   >>  95 public: // With description
                                                   >>  96 
                                                   >>  97         ////////////////////////////////
                                                   >>  98         // Constructors and Destructor
                                                   >>  99         ////////////////////////////////
                                                   >> 100 
                                                   >> 101   G4OpticalSurface(const G4String& name,
                                                   >> 102        G4OpticalSurfaceModel model = glisur,
                                                   >> 103        G4OpticalSurfaceFinish finish = polished,
                                                   >> 104        G4SurfaceType type = dielectric_dielectric,
                                                   >> 105        G4double value = 1.0);
                                                   >> 106         // Constructor of an optical surface object.
                                                   >> 107 
                                                   >> 108 public: // Without description
                                                   >> 109 
                                                   >> 110   ~G4OpticalSurface();
                                                   >> 111 
                                                   >> 112   ////////////
                                                   >> 113   // Methods
                                                   >> 114         ////////////
                                                   >> 115 
                                                   >> 116   // public methods
                                                   >> 117 
                                                   >> 118 public: // With description
                                                   >> 119 
                                                   >> 120         G4OpticalSurfaceFinish GetFinish() const {return theFinish;};
                                                   >> 121         // Returns the optical surface finish.
                                                   >> 122         void         SetFinish(const G4OpticalSurfaceFinish finish)
                                                   >> 123              {theFinish = finish;};
                                                   >> 124         // Sets the optical surface finish.
                                                   >> 125 
                                                   >> 126         G4OpticalSurfaceModel GetModel() const {return theModel;};
                                                   >> 127         // Returns the optical surface model used.
                                                   >> 128         void           SetModel(const G4OpticalSurfaceModel model)
                                                   >> 129                {theModel = model;};
                                                   >> 130         // Sets the optical surface model to be followed.
                                                   >> 131 
                                                   >> 132   G4double GetSigmaAlpha() const {return sigma_alpha;};
                                                   >> 133         // Returns an unified model surface parameter.
                                                   >> 134   void     SetSigmaAlpha(const G4double s_a)
                                                   >> 135                 {sigma_alpha = s_a;};
                                                   >> 136         // Sets an unified model surface parameter.
                                                   >> 137 
                                                   >> 138   G4double GetPolish() const {return polish;};
                                                   >> 139         // Returns the optical surface polish type.
                                                   >> 140   void     SetPolish(const G4double plsh) {polish=plsh;};
                                                   >> 141         // Sets the optical surface polish type.
                                                   >> 142 
                                                   >> 143   G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
                                                   >> 144                { return theMaterialPropertiesTable;};
                                                   >> 145         // Retrieves the pointer of the G4MaterialPropertiesTable 
                                                   >> 146         // attached to optical surface.
                                                   >> 147 
                                                   >> 148   void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
                                                   >> 149             { theMaterialPropertiesTable = anMPT;};
                                                   >> 150         // Attaches a G4MaterialPropertiesTable to the optical surface.
                                                   >> 151 
                                                   >> 152   void DumpInfo() const;
                                                   >> 153         // Prints information about the optical surface.
                                                   >> 154 
                                                   >> 155 private:
                                                   >> 156 
                                                   >> 157 // ------------------
                                                   >> 158 // Basic data members ( To define an optical surface)
                                                   >> 159 // ------------------
157                                                   160 
158   // Sets the optical surface polish type.     << 161         G4OpticalSurfaceModel theModel;   // Surface model
159   inline void SetPolish(const G4double plsh) { << 162         G4OpticalSurfaceFinish theFinish; // Surface finish
160                                                   163 
161   // Retrieves the pointer of the G4MaterialPr << 164   G4double sigma_alpha;   // The sigma of micro-facet polar angle
162   // attached to optical surface.              << 165   G4double polish;    // Polish parameter in glisur model
163   inline G4MaterialPropertiesTable* GetMateria << 
164   {                                            << 
165     return theMaterialPropertiesTable;         << 
166   }                                            << 
167                                                   166 
168   // Attaches a G4MaterialPropertiesTable to t << 167   G4MaterialPropertiesTable* theMaterialPropertiesTable;
169   inline void SetMaterialPropertiesTable(G4Mat << 
170   {                                            << 
171     theMaterialPropertiesTable = anMPT;        << 
172   }                                            << 
173                                                   168 
174   // Prints information about the optical surf << 
175   void DumpInfo() const;                       << 
176                                                << 
177   // call the correct ReadXXXFile              << 
178   void ReadDataFile();                         << 
179                                                << 
180   // read a zlib-compressed file               << 
181   void ReadCompressedFile(const G4String&, std << 
182                                                << 
183   // Method to read the Look-Up-Table into arr << 
184   void ReadLUTFile();                          << 
185                                                << 
186   // for DAVIS model                           << 
187   inline G4double GetAngularDistributionValue( << 
188                                                << 
189   // Returns the AngularDistributionValue      << 
190   inline G4double GetAngularDistributionValueL << 
191                                                << 
192   // Method to read the Davis Look-Up-Table in << 
193   void ReadLUTDAVISFile();                     << 
194                                                << 
195   // Method to read the Look-Up-Table for refl << 
196   void ReadReflectivityLUTFile();              << 
197                                                << 
198   // Returns the reflectivity value from the D << 
199   inline G4double GetReflectivityLUTValue(G4in << 
200                                                << 
201   // Returns the number of lines in the Davis  << 
202   G4int GetInmax() const;                      << 
203                                                << 
204   // Returns the number of probability values  << 
205   G4int GetLUTbins() const;                    << 
206                                                << 
207   // Returns the number of reflectivity values << 
208   G4int GetRefMax() const;                     << 
209                                                << 
210   G4int GetThetaIndexMax() const;              << 
211   G4int GetPhiIndexMax() const;                << 
212                                                << 
213   // Method to read the dichroic surface data  << 
214   void ReadDichroicFile();                     << 
215                                                << 
216   inline G4Physics2DVector* GetDichroicVector( << 
217                                                << 
218  private:                                      << 
219   G4OpticalSurfaceModel theModel;  // Surface  << 
220   G4OpticalSurfaceFinish theFinish;  // Surfac << 
221                                                << 
222   G4double sigma_alpha;  // The sigma of micro << 
223   G4double polish;  // Polish parameter in gli << 
224                                                << 
225   G4MaterialPropertiesTable* theMaterialProper << 
226                                                << 
227   static const G4int incidentIndexMax = 91;    << 
228   static const G4int thetaIndexMax = 45;       << 
229   static const G4int phiIndexMax = 37;         << 
230                                                << 
231   G4float* AngularDistribution;                << 
232   G4Physics2DVector* DichroicVector;           << 
233                                                << 
234   // for DAVIS model                           << 
235   static const G4int indexmax = 7280001;  // 3 << 
236   static const G4int RefMax = 90;              << 
237   static const G4int LUTbins = 20000;          << 
238   G4float* AngularDistributionLUT;             << 
239   G4float* Reflectivity;                       << 
240 };                                                169 };
241                                                   170 
242 ////////////////////                              171 ////////////////////
243 // Inline methods                                 172 // Inline methods
244 ////////////////////                              173 ////////////////////
245                                                << 
246 inline G4double G4OpticalSurface::GetAngularDi << 
247   G4int angleIncident, G4int thetaIndex, G4int << 
248 {                                              << 
249   G4int product = angleIncident * thetaIndex * << 
250   if (product < 0 || product >= incidentIndexM << 
251     G4ExceptionDescription ed;                 << 
252     ed << "Index angleIncident: " << angleInci << 
253        << " phiIndex: " << phiIndex << " out o << 
254     G4Exception("G4OpticalSurface::GetAngularD << 
255     return 0.;                                 << 
256   }                                            << 
257   return (G4double)AngularDistribution[angleIn << 
258                                        phiInde << 
259 }                                              << 
260                                                << 
261 inline G4double G4OpticalSurface::GetAngularDi << 
262 {                                              << 
263   if (i < 0 || i >= indexmax) {                << 
264     G4ExceptionDescription ed;                 << 
265     ed << "Index " << i << " out of range!";   << 
266     G4Exception("G4OpticalSurface::GetAngularD << 
267     return 0.;                                 << 
268   }                                            << 
269   return (G4double)AngularDistributionLUT[i];  << 
270 }                                              << 
271                                                << 
272 inline G4double G4OpticalSurface::GetReflectiv << 
273 {                                              << 
274   if (i < 0 || i >= RefMax) {                  << 
275     G4ExceptionDescription ed;                 << 
276     ed << "Index " << i << " out of range!";   << 
277     G4Exception("G4OpticalSurface::GetReflecti << 
278     return 0.;                                 << 
279   }                                            << 
280   return (G4double)Reflectivity[i];            << 
281 }                                              << 
282                                                << 
283 inline G4Physics2DVector* G4OpticalSurface::Ge << 
284                                                   174 
285 #endif /* G4OpticalSurface_h */                   175 #endif /* G4OpticalSurface_h */
286                                                   176