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 1.0)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  5 // * The  Geant4 software  is  copyright of th <<   7 //
  6 // * the Geant4 Collaboration.  It is provided <<   8 // $Id: G4OpticalSurface.hh,v 1.4 1999/11/05 21:12:05 gum Exp $
  7 // * conditions of the Geant4 Software License <<   9 // GEANT4 tag $Name: geant4-01-00 $
  8 // * LICENSE and available at  http://cern.ch/ <<  10 //
  9 // * include a list of copyright holders.      <<  11 // 
 10 // *                                           << 
 11 // * Neither the authors of this software syst << 
 12 // * institutes,nor the agencies providing fin << 
 13 // * work  make  any representation or  warran << 
 14 // * regarding  this  software system or assum << 
 15 // * use.  Please see the license in the file  << 
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                           << 
 18 // * This  code  implementation is the result  << 
 19 // * technical work of the GEANT4 collaboratio << 
 20 // * By using,  copying,  modifying or  distri << 
 21 // * any work based  on the software)  you  ag << 
 22 // * use  in  resulting  scientific  publicati << 
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // ******************************************* << 
 25                                                << 
 26 //////////////////////////////////////////////     12 ////////////////////////////////////////////////////////////////////////
 27 // G4OpticalSurface Definition                     13 // G4OpticalSurface Definition
 28 //////////////////////////////////////////////     14 ////////////////////////////////////////////////////////////////////////
 29 //                                                 15 //
 30 // File:        G4OpticalSurface.hh                16 // File:        G4OpticalSurface.hh
 31 // Description: A optical surface class for us     17 // Description: A optical surface class for use in G4OpBoundaryProcess
 32 // Version:     2.0                                18 // Version:     2.0
 33 // Created:     1997-06-26                         19 // Created:     1997-06-26
 34 // Author:      Peter Gumplinger                   20 // Author:      Peter Gumplinger
 35 // Updated:     1999-10-29 add method and clas     21 // Updated:     1999-10-29 add method and class descriptors
 36 //              2017-02-24 Mariele Stockhoff a <<  22 // mail:        gum@triumf.ca
 37 //                                                 23 //
 38 // Class Description:                          <<  24 // Cvs version: 
 39 // A optical surface class for use in the G4Op << 
 40 // Contains the enumerations: G4OpticalSurface << 
 41 // and G4OpticalSurfaceModel.                  << 
 42 //////////////////////////////////////////////     25 ////////////////////////////////////////////////////////////////////////
 43                                                    26 
 44 #ifndef G4OpticalSurface_h                         27 #ifndef G4OpticalSurface_h
 45 #define G4OpticalSurface_h 1                       28 #define G4OpticalSurface_h 1
 46                                                    29 
 47 #include "G4Physics2DVector.hh"                <<  30 /////////////
 48 #include "G4SurfaceProperty.hh"                <<  31 // Includes
 49 #include "G4Types.hh"                          <<  32 /////////////
                                                   >>  33 
                                                   >>  34 #include "globals.hh"
                                                   >>  35 #include "templates.hh"
                                                   >>  36 
                                                   >>  37 // Class Description:
                                                   >>  38 // A optical surface class for use in the G4OpBoundaryProcess class.
                                                   >>  39 // Contains the enumerations: G4OpticalSurfaceFinish, G4OpticalSurfaceType,
                                                   >>  40 // and G4OpticalSurfaceModel.
                                                   >>  41 // Class Description - End:
 50                                                    42 
 51 // clang-format off                            << 
 52 enum G4OpticalSurfaceFinish                        43 enum G4OpticalSurfaceFinish
 53 {                                                  44 {
 54   polished,              // smooth perfectly p <<  45    polished,                    // smooth perfectly polished surface
 55   polishedfrontpainted,  // smooth top-layer ( <<  46    polishedfrontpainted,        // smooth top-layer (front) paint
 56   polishedbackpainted,   // same is 'polished' <<  47    polishedbackpainted,         // same is 'polished' but with a back-paint
 57                                                <<  48    ground,                      // rough surface
 58   ground,              // rough surface        <<  49    groundfrontpainted,          // rough top-layer (front) paint
 59   groundfrontpainted,  // rough top-layer (fro <<  50    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 };                                                 51 };
105                                                    52 
106 enum G4OpticalSurfaceModel                     <<  53 enum G4OpticalSurfaceType
107 {                                                  54 {
108   glisur,   // original GEANT3 model           <<  55    dielectric_metal,            // dielectric-metal interface
109   unified,  // UNIFIED model                   <<  56    dielectric_dielectric        // dielectric-dielectric interface
110   LUT,      // Look-Up-Table model (LBNL model << 
111   DAVIS,    // DAVIS model                     << 
112   dichroic  // dichroic filter                 << 
113 };                                                 57 };
114                                                    58 
115 // clang-format on                             <<  59 enum G4OpticalSurfaceModel
116                                                << 
117 class G4MaterialPropertiesTable;               << 
118                                                << 
119 class G4OpticalSurface : public G4SurfacePrope << 
120 {                                                  60 {
121  public:                                       <<  61    glisur,                      // original GEANT3 model
122   // Constructor of an optical surface object. <<  62    unified                      // UNIFIED model
123   G4OpticalSurface(const G4String& name, G4Opt <<  63 };
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                                                    64 
137   // Returns the optical surface finish.       <<  65 class G4MaterialPropertiesTable;
138   inline G4OpticalSurfaceFinish GetFinish() co << 
139                                                    66 
140   // Sets the optical surface finish.          <<  67 /////////////////////
141   void SetFinish(const G4OpticalSurfaceFinish) <<  68 // Class Definition
                                                   >>  69 /////////////////////
142                                                    70 
143   // Returns the optical surface model used.   <<  71 class G4OpticalSurface
144   inline G4OpticalSurfaceModel GetModel() cons <<  72 {
145                                                    73 
146   // Sets the optical surface model to be foll <<  74 public: // Without description
147   inline void SetModel(const G4OpticalSurfaceM << 
148                                                    75 
149   // Returns an unified model surface paramete <<  76         //////////////
150   inline G4double GetSigmaAlpha() const { retu <<  77         // Operators
                                                   >>  78         //////////////
151                                                    79 
152   // Sets an unified model surface parameter.  <<  80         G4OpticalSurface(const G4OpticalSurface &right);
153   inline void SetSigmaAlpha(const G4double s_a <<  81   const G4OpticalSurface & operator=(const G4OpticalSurface &right);
154                                                    82 
155   // Returns the optical surface polish type.  <<  83   G4int operator==(const G4OpticalSurface &right) const;
156   G4double GetPolish() const { return polish;  <<  84   G4int operator!=(const G4OpticalSurface &right) const;
157                                                    85 
158   // Sets the optical surface polish type.     <<  86 public: // With description
159   inline void SetPolish(const G4double plsh) { << 
160                                                    87 
161   // Retrieves the pointer of the G4MaterialPr <<  88         ////////////////////////////////
162   // attached to optical surface.              <<  89         // Constructors and Destructor
163   inline G4MaterialPropertiesTable* GetMateria <<  90         ////////////////////////////////
164   {                                            << 
165     return theMaterialPropertiesTable;         << 
166   }                                            << 
167                                                    91 
168   // Attaches a G4MaterialPropertiesTable to t <<  92   G4OpticalSurface(const G4String& name,
169   inline void SetMaterialPropertiesTable(G4Mat <<  93        G4OpticalSurfaceModel model = glisur,
170   {                                            <<  94        G4OpticalSurfaceFinish finish = polished,
171     theMaterialPropertiesTable = anMPT;        <<  95        G4OpticalSurfaceType type = dielectric_dielectric,
172   }                                            <<  96        G4double value = 1.0);
                                                   >>  97         // Constructor of an optical surface object.
173                                                    98 
174   // Prints information about the optical surf <<  99 public: // Without description
175   void DumpInfo() const;                       << 
176                                                   100 
177   // call the correct ReadXXXFile              << 101   ~G4OpticalSurface();
178   void ReadDataFile();                         << 
179                                                   102 
180   // read a zlib-compressed file               << 103   ////////////
181   void ReadCompressedFile(const G4String&, std << 104   // Methods
                                                   >> 105         ////////////
182                                                   106 
183   // Method to read the Look-Up-Table into arr << 107   // public methods
184   void ReadLUTFile();                          << 
185                                                   108 
186   // for DAVIS model                           << 109 public: // With description
187   inline G4double GetAngularDistributionValue( << 
188                                                   110 
189   // Returns the AngularDistributionValue      << 111   G4String GetName() const { return theName; };
190   inline G4double GetAngularDistributionValueL << 112         // Returns the optical surface name.
                                                   >> 113   void     SetName(const G4String& name){theName = name;};
                                                   >> 114         // Sets the optical surface name.
191                                                   115 
192   // Method to read the Davis Look-Up-Table in << 116         G4OpticalSurfaceType GetType() const {return theType;};
193   void ReadLUTDAVISFile();                     << 117         // Returns the optical surface type.
                                                   >> 118         void         SetType(const G4OpticalSurfaceType type){theType = type;};
                                                   >> 119         // Sets the optical surface type.        
194                                                   120 
195   // Method to read the Look-Up-Table for refl << 121         G4OpticalSurfaceFinish GetFinish() const {return theFinish;};
196   void ReadReflectivityLUTFile();              << 122         // Returns the optical surface finish.
                                                   >> 123         void         SetFinish(const G4OpticalSurfaceFinish finish)
                                                   >> 124              {theFinish = finish;};
                                                   >> 125         // Sets the optical surface finish.
197                                                   126 
198   // Returns the reflectivity value from the D << 127         G4OpticalSurfaceModel GetModel() const {return theModel;};
199   inline G4double GetReflectivityLUTValue(G4in << 128         // Returns the optical surface model used.
                                                   >> 129         void           SetModel(const G4OpticalSurfaceModel model)
                                                   >> 130                {theModel = model;};
                                                   >> 131         // Sets the optical surface model to be followed.
200                                                   132 
201   // Returns the number of lines in the Davis  << 133   G4double GetSigmaAlpha() const {return sigma_alpha;};
202   G4int GetInmax() const;                      << 134         // Returns an unified model surface parameter.
                                                   >> 135   void     SetSigmaAlpha(const G4double s_a)
                                                   >> 136                 {sigma_alpha = s_a;};
                                                   >> 137         // Sets an unified model surface parameter.
203                                                   138 
204   // Returns the number of probability values  << 139   G4double GetPolish() const {return polish;};
205   G4int GetLUTbins() const;                    << 140         // Returns the optical surface polish type.
                                                   >> 141   void     SetPolish(const G4double plsh) {polish=plsh;};
                                                   >> 142         // Sets the optical surface polish type.
206                                                   143 
207   // Returns the number of reflectivity values << 144   G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
208   G4int GetRefMax() const;                     << 145                { return theMaterialPropertiesTable;};
                                                   >> 146         // Retrieves the pointer of the G4MaterialPropertiesTable 
                                                   >> 147         // attached to optical surface.
209                                                   148 
210   G4int GetThetaIndexMax() const;              << 149   void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
211   G4int GetPhiIndexMax() const;                << 150             { theMaterialPropertiesTable = anMPT;};
                                                   >> 151         // Attaches a G4MaterialPropertiesTable to the optical surface.
212                                                   152 
213   // Method to read the dichroic surface data  << 153   void DumpInfo() const;
214   void ReadDichroicFile();                     << 154         // Prints information about the optical surface.
215                                                   155 
216   inline G4Physics2DVector* GetDichroicVector( << 156 private:
217                                                   157 
218  private:                                      << 158 // ------------------
219   G4OpticalSurfaceModel theModel;  // Surface  << 159 // Basic data members ( To define an optical surface)
220   G4OpticalSurfaceFinish theFinish;  // Surfac << 160 // ------------------
221                                                   161 
222   G4double sigma_alpha;  // The sigma of micro << 162   G4String theName;     // Surface name
223   G4double polish;  // Polish parameter in gli << 
224                                                   163 
225   G4MaterialPropertiesTable* theMaterialProper << 164         G4OpticalSurfaceModel theModel;   // Surface model
                                                   >> 165         G4OpticalSurfaceFinish theFinish; // Surface finish
                                                   >> 166   G4OpticalSurfaceType theType;   // Surface type
226                                                   167 
227   static const G4int incidentIndexMax = 91;    << 168   G4double sigma_alpha;   // The sigma of micro-facet polar angle
228   static const G4int thetaIndexMax = 45;       << 169   G4double polish;    // Polish parameter in glisur model
229   static const G4int phiIndexMax = 37;         << 
230                                                   170 
231   G4float* AngularDistribution;                << 171   G4MaterialPropertiesTable* theMaterialPropertiesTable;
232   G4Physics2DVector* DichroicVector;           << 
233                                                   172 
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 };                                                173 };
241                                                   174 
242 ////////////////////                              175 ////////////////////
243 // Inline methods                                 176 // Inline methods
244 ////////////////////                              177 ////////////////////
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                                                   178 
285 #endif /* G4OpticalSurface_h */                   179 #endif /* G4OpticalSurface_h */
286                                                   180