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 11.0.p3,)


** Warning: Cannot open xref database.

  1 //                                                  1 
  2 // *******************************************    
  3 // * License and Disclaimer                       
  4 // *                                              
  5 // * The  Geant4 software  is  copyright of th    
  6 // * the Geant4 Collaboration.  It is provided    
  7 // * conditions of the Geant4 Software License    
  8 // * LICENSE and available at  http://cern.ch/    
  9 // * include a list of copyright holders.         
 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 //////////////////////////////////////////////    
 27 // G4OpticalSurface Definition                    
 28 //////////////////////////////////////////////    
 29 //                                                
 30 // File:        G4OpticalSurface.hh               
 31 // Description: A optical surface class for us    
 32 // Version:     2.0                               
 33 // Created:     1997-06-26                        
 34 // Author:      Peter Gumplinger                  
 35 // Updated:     1999-10-29 add method and clas    
 36 //              2017-02-24 Mariele Stockhoff a    
 37 //                                                
 38 // Class Description:                             
 39 // A optical surface class for use in the G4Op    
 40 // Contains the enumerations: G4OpticalSurface    
 41 // and G4OpticalSurfaceModel.                     
 42 //////////////////////////////////////////////    
 43                                                   
 44 #ifndef G4OpticalSurface_h                        
 45 #define G4OpticalSurface_h 1                      
 46                                                   
 47 #include "G4Physics2DVector.hh"                   
 48 #include "G4SurfaceProperty.hh"                   
 49 #include "G4Types.hh"                             
 50                                                   
 51 // clang-format off                               
 52 enum G4OpticalSurfaceFinish                       
 53 {                                                 
 54   polished,              // smooth perfectly p    
 55   polishedfrontpainted,  // smooth top-layer (    
 56   polishedbackpainted,   // same is 'polished'    
 57                                                   
 58   ground,              // rough surface           
 59   groundfrontpainted,  // rough top-layer (fro    
 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 };                                                
105                                                   
106 enum G4OpticalSurfaceModel                        
107 {                                                 
108   glisur,   // original GEANT3 model              
109   unified,  // UNIFIED model                      
110   LUT,      // Look-Up-Table model (LBNL model    
111   DAVIS,    // DAVIS model                        
112   dichroic  // dichroic filter                    
113 };                                                
114                                                   
115 // clang-format on                                
116                                                   
117 class G4MaterialPropertiesTable;                  
118                                                   
119 class G4OpticalSurface : public G4SurfacePrope    
120 {                                                 
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                                                   
155   // Returns the optical surface polish type.     
156   G4double GetPolish() const { return polish;     
157                                                   
158   // Sets the optical surface polish type.        
159   inline void SetPolish(const G4double plsh) {    
160                                                   
161   // Retrieves the pointer of the G4MaterialPr    
162   // attached to optical surface.                 
163   inline G4MaterialPropertiesTable* GetMateria    
164   {                                               
165     return theMaterialPropertiesTable;            
166   }                                               
167                                                   
168   // Attaches a G4MaterialPropertiesTable to t    
169   inline void SetMaterialPropertiesTable(G4Mat    
170   {                                               
171     theMaterialPropertiesTable = anMPT;           
172   }                                               
173                                                   
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 };                                                
241                                                   
242 ////////////////////                              
243 // Inline methods                                 
244 ////////////////////                              
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                                                   
285 #endif /* G4OpticalSurface_h */                   
286