Geant4 Cross Reference |
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-08-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