Geant4 Cross Reference |
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.11 2008/12/11 10:23:54 gcosmo Exp $ >> 28 // GEANT4 tag $Name: geant4-09-02-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 85 152 // Sets an unified model surface parameter. << 86 public: // With description 153 inline void SetSigmaAlpha(const G4double s_a << 154 87 155 // Returns the optical surface polish type. << 88 //////////////////////////////// 156 G4double GetPolish() const { return polish; << 89 // Constructor >> 90 //////////////////////////////// >> 91 >> 92 G4OpticalSurface(const G4String& name, >> 93 G4OpticalSurfaceModel model = glisur, >> 94 G4OpticalSurfaceFinish finish = polished, >> 95 G4SurfaceType type = dielectric_dielectric, >> 96 G4double value = 1.0); >> 97 // Constructor of an optical surface object. >> 98 >> 99 public: // Without description >> 100 >> 101 ////////////// >> 102 // Constructors and destructor >> 103 ////////////// >> 104 >> 105 G4OpticalSurface(); >> 106 virtual ~G4OpticalSurface(); >> 107 G4OpticalSurface(const G4OpticalSurface &right); >> 108 >> 109 ////////////// >> 110 // Operators >> 111 ////////////// >> 112 >> 113 const G4OpticalSurface & operator=(const G4OpticalSurface &right); >> 114 >> 115 G4int operator==(const G4OpticalSurface &right) const; >> 116 G4int operator!=(const G4OpticalSurface &right) const; >> 117 >> 118 //////////// >> 119 // Methods >> 120 //////////// >> 121 >> 122 public: // With description >> 123 >> 124 G4OpticalSurfaceFinish GetFinish() const {return theFinish;}; >> 125 // Returns the optical surface finish. >> 126 void SetFinish(const G4OpticalSurfaceFinish finish) >> 127 {theFinish = finish;}; >> 128 // Sets the optical surface finish. >> 129 >> 130 G4OpticalSurfaceModel GetModel() const {return theModel;}; >> 131 // Returns the optical surface model used. >> 132 void SetModel(const G4OpticalSurfaceModel model) >> 133 {theModel = model;}; >> 134 // Sets the optical surface model to be followed. >> 135 >> 136 G4double GetSigmaAlpha() const {return sigma_alpha;}; >> 137 // Returns an unified model surface parameter. >> 138 void SetSigmaAlpha(const G4double s_a) >> 139 {sigma_alpha = s_a;}; >> 140 // Sets an unified model surface parameter. >> 141 >> 142 G4double GetPolish() const {return polish;}; >> 143 // Returns the optical surface polish type. >> 144 void SetPolish(const G4double plsh) {polish=plsh;}; >> 145 // Sets the optical surface polish type. >> 146 >> 147 G4MaterialPropertiesTable* GetMaterialPropertiesTable() const >> 148 { return theMaterialPropertiesTable;}; >> 149 // Retrieves the pointer of the G4MaterialPropertiesTable >> 150 // attached to optical surface. >> 151 >> 152 void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT) >> 153 { theMaterialPropertiesTable = anMPT;}; >> 154 // Attaches a G4MaterialPropertiesTable to the optical surface. >> 155 >> 156 void DumpInfo() const; >> 157 // Prints information about the optical surface. >> 158 >> 159 private: >> 160 >> 161 // ------------------ >> 162 // Basic data members ( To define an optical surface) >> 163 // ------------------ 157 164 158 // Sets the optical surface polish type. << 165 G4OpticalSurfaceModel theModel; // Surface model 159 inline void SetPolish(const G4double plsh) { << 166 G4OpticalSurfaceFinish theFinish; // Surface finish 160 167 161 // Retrieves the pointer of the G4MaterialPr << 168 G4double sigma_alpha; // The sigma of micro-facet polar angle 162 // attached to optical surface. << 169 G4double polish; // Polish parameter in glisur model 163 inline G4MaterialPropertiesTable* GetMateria << 164 { << 165 return theMaterialPropertiesTable; << 166 } << 167 170 168 // Attaches a G4MaterialPropertiesTable to t << 171 G4MaterialPropertiesTable* theMaterialPropertiesTable; 169 inline void SetMaterialPropertiesTable(G4Mat << 170 { << 171 theMaterialPropertiesTable = anMPT; << 172 } << 173 172 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 }; 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