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 9.0.p2)


  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 //
                                                   >>  27 // $Id: G4OpticalSurface.hh,v 1.8 2006/06/29 19:12:31 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-03-patch-01 $
                                                   >>  29 //
                                                   >>  30 // 
 26 //////////////////////////////////////////////     31 ////////////////////////////////////////////////////////////////////////
 27 // G4OpticalSurface Definition                     32 // G4OpticalSurface Definition
 28 //////////////////////////////////////////////     33 ////////////////////////////////////////////////////////////////////////
 29 //                                                 34 //
 30 // File:        G4OpticalSurface.hh                35 // File:        G4OpticalSurface.hh
 31 // Description: A optical surface class for us     36 // Description: A optical surface class for use in G4OpBoundaryProcess
 32 // Version:     2.0                                37 // Version:     2.0
 33 // Created:     1997-06-26                         38 // Created:     1997-06-26
 34 // Author:      Peter Gumplinger                   39 // Author:      Peter Gumplinger
 35 // Updated:     1999-10-29 add method and clas     40 // Updated:     1999-10-29 add method and class descriptors
 36 //              2017-02-24 Mariele Stockhoff a <<  41 // mail:        gum@triumf.ca
 37 //                                                 42 //
 38 // Class Description:                          << 
 39 // A optical surface class for use in the G4Op << 
 40 // Contains the enumerations: G4OpticalSurface << 
 41 // and G4OpticalSurfaceModel.                  << 
 42 //////////////////////////////////////////////     43 ////////////////////////////////////////////////////////////////////////
 43                                                    44 
 44 #ifndef G4OpticalSurface_h                         45 #ifndef G4OpticalSurface_h
 45 #define G4OpticalSurface_h 1                       46 #define G4OpticalSurface_h 1
 46                                                    47 
 47 #include "G4Physics2DVector.hh"                <<  48 /////////////
 48 #include "G4SurfaceProperty.hh"                <<  49 // Includes
                                                   >>  50 /////////////
                                                   >>  51 
 49 #include "G4Types.hh"                              52 #include "G4Types.hh"
                                                   >>  53 #include "G4SurfaceProperty.hh"
                                                   >>  54 
                                                   >>  55 // Class Description:
                                                   >>  56 // A optical surface class for use in the G4OpBoundaryProcess class.
                                                   >>  57 // Contains the enumerations: G4OpticalSurfaceFinish, G4OpticalSurfaceType,
                                                   >>  58 // and G4OpticalSurfaceModel.
                                                   >>  59 // Class Description - End:
 50                                                    60 
 51 // clang-format off                            << 
 52 enum G4OpticalSurfaceFinish                        61 enum G4OpticalSurfaceFinish
 53 {                                                  62 {
 54   polished,              // smooth perfectly p <<  63    polished,                    // smooth perfectly polished surface
 55   polishedfrontpainted,  // smooth top-layer ( <<  64    polishedfrontpainted,        // smooth top-layer (front) paint
 56   polishedbackpainted,   // same is 'polished' <<  65    polishedbackpainted,         // same is 'polished' but with a back-paint
 57                                                <<  66    ground,                      // rough surface
 58   ground,              // rough surface        <<  67    groundfrontpainted,          // rough top-layer (front) paint
 59   groundfrontpainted,  // rough top-layer (fro <<  68    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 };                                                 69 };
105                                                    70 
106 enum G4OpticalSurfaceModel                         71 enum G4OpticalSurfaceModel
107 {                                                  72 {
108   glisur,   // original GEANT3 model           <<  73    glisur,                      // original GEANT3 model
109   unified,  // UNIFIED model                   <<  74    unified                      // UNIFIED model
110   LUT,      // Look-Up-Table model (LBNL model << 
111   DAVIS,    // DAVIS model                     << 
112   dichroic  // dichroic filter                 << 
113 };                                                 75 };
114                                                    76 
115 // clang-format on                             << 
116                                                << 
117 class G4MaterialPropertiesTable;                   77 class G4MaterialPropertiesTable;
118                                                    78 
                                                   >>  79 /////////////////////
                                                   >>  80 // Class Definition
                                                   >>  81 /////////////////////
                                                   >>  82 
119 class G4OpticalSurface : public G4SurfacePrope     83 class G4OpticalSurface : public G4SurfaceProperty
120 {                                                  84 {
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                                                    85 
155   // Returns the optical surface polish type.  <<  86 public: // Without description
156   G4double GetPolish() const { return polish;  <<  87   
                                                   >>  88         //////////////
                                                   >>  89         // Operators
                                                   >>  90         //////////////
                                                   >>  91   
                                                   >>  92   G4OpticalSurface(const G4OpticalSurface &right);
                                                   >>  93   const G4OpticalSurface & operator=(const G4OpticalSurface &right);
                                                   >>  94   
                                                   >>  95   G4int operator==(const G4OpticalSurface &right) const;
                                                   >>  96   G4int operator!=(const G4OpticalSurface &right) const;
                                                   >>  97 
                                                   >>  98 public: // With description
                                                   >>  99 
                                                   >> 100         ////////////////////////////////
                                                   >> 101         // Constructors and Destructor
                                                   >> 102         ////////////////////////////////
                                                   >> 103 
                                                   >> 104   G4OpticalSurface(const G4String& name,
                                                   >> 105        G4OpticalSurfaceModel model = glisur,
                                                   >> 106        G4OpticalSurfaceFinish finish = polished,
                                                   >> 107        G4SurfaceType type = dielectric_dielectric,
                                                   >> 108        G4double value = 1.0);
                                                   >> 109         // Constructor of an optical surface object.
                                                   >> 110 
                                                   >> 111 public: // Without description
                                                   >> 112 
                                                   >> 113   ~G4OpticalSurface();
                                                   >> 114 
                                                   >> 115   ////////////
                                                   >> 116   // Methods
                                                   >> 117         ////////////
                                                   >> 118 
                                                   >> 119   // public methods
                                                   >> 120 
                                                   >> 121 public: // With description
                                                   >> 122 
                                                   >> 123         G4OpticalSurfaceFinish GetFinish() const {return theFinish;};
                                                   >> 124         // Returns the optical surface finish.
                                                   >> 125         void         SetFinish(const G4OpticalSurfaceFinish finish)
                                                   >> 126              {theFinish = finish;};
                                                   >> 127         // Sets the optical surface finish.
                                                   >> 128 
                                                   >> 129         G4OpticalSurfaceModel GetModel() const {return theModel;};
                                                   >> 130         // Returns the optical surface model used.
                                                   >> 131         void           SetModel(const G4OpticalSurfaceModel model)
                                                   >> 132                {theModel = model;};
                                                   >> 133         // Sets the optical surface model to be followed.
                                                   >> 134 
                                                   >> 135   G4double GetSigmaAlpha() const {return sigma_alpha;};
                                                   >> 136         // Returns an unified model surface parameter.
                                                   >> 137   void     SetSigmaAlpha(const G4double s_a)
                                                   >> 138                 {sigma_alpha = s_a;};
                                                   >> 139         // Sets an unified model surface parameter.
                                                   >> 140 
                                                   >> 141   G4double GetPolish() const {return polish;};
                                                   >> 142         // Returns the optical surface polish type.
                                                   >> 143   void     SetPolish(const G4double plsh) {polish=plsh;};
                                                   >> 144         // Sets the optical surface polish type.
                                                   >> 145 
                                                   >> 146   G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
                                                   >> 147                { return theMaterialPropertiesTable;};
                                                   >> 148         // Retrieves the pointer of the G4MaterialPropertiesTable 
                                                   >> 149         // attached to optical surface.
                                                   >> 150 
                                                   >> 151   void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
                                                   >> 152             { theMaterialPropertiesTable = anMPT;};
                                                   >> 153         // Attaches a G4MaterialPropertiesTable to the optical surface.
                                                   >> 154 
                                                   >> 155   void DumpInfo() const;
                                                   >> 156         // Prints information about the optical surface.
                                                   >> 157 
                                                   >> 158 private:
                                                   >> 159 
                                                   >> 160 // ------------------
                                                   >> 161 // Basic data members ( To define an optical surface)
                                                   >> 162 // ------------------
157                                                   163 
158   // Sets the optical surface polish type.     << 164         G4OpticalSurfaceModel theModel;   // Surface model
159   inline void SetPolish(const G4double plsh) { << 165         G4OpticalSurfaceFinish theFinish; // Surface finish
160                                                   166 
161   // Retrieves the pointer of the G4MaterialPr << 167   G4double sigma_alpha;   // The sigma of micro-facet polar angle
162   // attached to optical surface.              << 168   G4double polish;    // Polish parameter in glisur model
163   inline G4MaterialPropertiesTable* GetMateria << 
164   {                                            << 
165     return theMaterialPropertiesTable;         << 
166   }                                            << 
167                                                   169 
168   // Attaches a G4MaterialPropertiesTable to t << 170   G4MaterialPropertiesTable* theMaterialPropertiesTable;
169   inline void SetMaterialPropertiesTable(G4Mat << 
170   {                                            << 
171     theMaterialPropertiesTable = anMPT;        << 
172   }                                            << 
173                                                   171 
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 };                                                172 };
241                                                   173 
242 ////////////////////                              174 ////////////////////
243 // Inline methods                                 175 // Inline methods
244 ////////////////////                              176 ////////////////////
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                                                   177 
285 #endif /* G4OpticalSurface_h */                   178 #endif /* G4OpticalSurface_h */
286                                                   179