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 // >> 28 // 26 ////////////////////////////////////////////// 29 //////////////////////////////////////////////////////////////////////// 27 // G4OpticalSurface Definition 30 // G4OpticalSurface Definition 28 ////////////////////////////////////////////// 31 //////////////////////////////////////////////////////////////////////// 29 // 32 // 30 // File: G4OpticalSurface.hh 33 // File: G4OpticalSurface.hh 31 // Description: A optical surface class for us 34 // Description: A optical surface class for use in G4OpBoundaryProcess 32 // Version: 2.0 35 // Version: 2.0 33 // Created: 1997-06-26 36 // Created: 1997-06-26 34 // Author: Peter Gumplinger 37 // Author: Peter Gumplinger 35 // Updated: 1999-10-29 add method and clas 38 // Updated: 1999-10-29 add method and class descriptors 36 // 2017-02-24 Mariele Stockhoff a << 39 // 2017-02-24 Mariele Stockhoff add DAVIS model >> 40 // mail: gum@triumf.ca 37 // 41 // 38 // Class Description: << 39 // A optical surface class for use in the G4Op << 40 // Contains the enumerations: G4OpticalSurface << 41 // and G4OpticalSurfaceModel. << 42 ////////////////////////////////////////////// 42 //////////////////////////////////////////////////////////////////////// 43 43 44 #ifndef G4OpticalSurface_h 44 #ifndef G4OpticalSurface_h 45 #define G4OpticalSurface_h 1 45 #define G4OpticalSurface_h 1 46 46 >> 47 ///////////// >> 48 // Includes >> 49 ///////////// >> 50 >> 51 #include "G4Types.hh" 47 #include "G4Physics2DVector.hh" 52 #include "G4Physics2DVector.hh" 48 #include "G4SurfaceProperty.hh" 53 #include "G4SurfaceProperty.hh" 49 #include "G4Types.hh" << 50 54 51 // clang-format off << 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: >> 60 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 58 ground, // rough surface << 67 ground, // rough surface 59 groundfrontpainted, // rough top-layer (fro << 68 groundfrontpainted, // rough top-layer (front) paint 60 groundbackpainted, // same as 'ground' but << 69 groundbackpainted, // same as 'ground' but with a back-paint 61 << 70 62 // for LBNL LUT model << 71 polishedlumirrorair, // mechanically polished surface, with lumirror 63 polishedlumirrorair, // mechanically polis << 72 polishedlumirrorglue, // mechanically polished surface, with lumirror & meltmount 64 polishedlumirrorglue, // mechanically polis << 73 polishedair, // mechanically polished surface 65 // meltmount << 74 polishedteflonair, // mechanically polished surface, with teflon 66 polishedair, // mechanically polis << 75 polishedtioair, // mechanically polished surface, with tio paint 67 polishedteflonair, // mechanically polis << 76 polishedtyvekair, // mechanically polished surface, with tyvek 68 polishedtioair, // mechanically polis << 77 polishedvm2000air, // mechanically polished surface, with esr film 69 polishedtyvekair, // mechanically polis << 78 polishedvm2000glue, // mechanically polished surface, with esr film & meltmount 70 polishedvm2000air, // mechanically polis << 79 71 polishedvm2000glue, // mechanically polis << 80 etchedlumirrorair, // chemically etched surface, with lumirror 72 // meltmount << 81 etchedlumirrorglue, // chemically etched surface, with lumirror & meltmount 73 << 82 etchedair, // chemically etched surface 74 etchedlumirrorair, // chemically etched su << 83 etchedteflonair, // chemically etched surface, with teflon 75 etchedlumirrorglue, // chemically etched su << 84 etchedtioair, // chemically etched surface, with tio paint 76 etchedair, // chemically etched su << 85 etchedtyvekair, // chemically etched surface, with tyvek 77 etchedteflonair, // chemically etched su << 86 etchedvm2000air, // chemically etched surface, with esr film 78 etchedtioair, // chemically etched su << 87 etchedvm2000glue, // chemically etched surface, with esr film & meltmount 79 etchedtyvekair, // chemically etched su << 88 80 etchedvm2000air, // chemically etched su << 89 groundlumirrorair, // rough-cut surface, with lumirror 81 etchedvm2000glue, // chemically etched su << 90 groundlumirrorglue, // rough-cut surface, with lumirror & meltmount 82 << 91 groundair, // rough-cut surface 83 groundlumirrorair, // rough-cut surface, w << 92 groundteflonair, // rough-cut surface, with teflon 84 groundlumirrorglue, // rough-cut surface, w << 93 groundtioair, // rough-cut surface, with tio paint 85 groundair, // rough-cut surface << 94 groundtyvekair, // rough-cut surface, with tyvek 86 groundteflonair, // rough-cut surface, w << 95 groundvm2000air, // rough-cut surface, with esr film 87 groundtioair, // rough-cut surface, w << 96 groundvm2000glue, // rough-cut surface, with esr film & meltmount 88 groundtyvekair, // rough-cut surface, w << 97 89 groundvm2000air, // rough-cut surface, w << 98 // for DAVIS model 90 groundvm2000glue, // rough-cut surface, w << 99 Rough_LUT, //rough surface 91 << 100 RoughTeflon_LUT, //rough surface wrapped in Teflon tape 92 // for DAVIS model << 101 RoughESR_LUT, //rough surface wrapped with ESR 93 Rough_LUT, // rough surface << 102 RoughESRGrease_LUT, //rough surface wrapped with ESR 94 RoughTeflon_LUT, // rough surface wra << 103 //and coupled with opical grease 95 RoughESR_LUT, // rough surface wra << 104 Polished_LUT, //polished surface 96 RoughESRGrease_LUT, // rough surface wra << 105 PolishedTeflon_LUT, //polished surface wrapped in Teflon tape 97 // and coupled with << 106 PolishedESR_LUT, //polished surface wrapped with ESR 98 Polished_LUT, // polished surface << 107 PolishedESRGrease_LUT, //polished surface wrapped with ESR 99 PolishedTeflon_LUT, // polished surface << 108 //and coupled with opical grease 100 PolishedESR_LUT, // polished surface << 109 Detector_LUT //polished surface with optical grease 101 PolishedESRGrease_LUT, // polished surface << 102 // and coupled with << 103 Detector_LUT // polished surface << 104 }; 110 }; 105 111 106 enum G4OpticalSurfaceModel 112 enum G4OpticalSurfaceModel 107 { 113 { 108 glisur, // original GEANT3 model << 114 glisur, // original GEANT3 model 109 unified, // UNIFIED model << 115 unified, // UNIFIED model 110 LUT, // Look-Up-Table model (LBNL model << 116 LUT, // Look-Up-Table model 111 DAVIS, // DAVIS model << 117 DAVIS, // DAVIS model 112 dichroic // dichroic filter << 118 dichroic // dichroic filter 113 }; 119 }; 114 120 115 // clang-format on << 116 << 117 class G4MaterialPropertiesTable; 121 class G4MaterialPropertiesTable; 118 122 >> 123 ///////////////////// >> 124 // Class Definition >> 125 ///////////////////// >> 126 119 class G4OpticalSurface : public G4SurfacePrope 127 class G4OpticalSurface : public G4SurfaceProperty 120 { 128 { 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 129 152 // Sets an unified model surface parameter. << 130 public: // Without description 153 inline void SetSigmaAlpha(const G4double s_a << 131 154 << 132 ////////////// 155 // Returns the optical surface polish type. << 133 // Operators 156 G4double GetPolish() const { return polish; << 134 ////////////// 157 << 135 158 // Sets the optical surface polish type. << 136 G4OpticalSurface(const G4OpticalSurface &right); 159 inline void SetPolish(const G4double plsh) { << 137 G4OpticalSurface & operator=(const G4OpticalSurface &right); 160 << 138 161 // Retrieves the pointer of the G4MaterialPr << 139 G4int operator==(const G4OpticalSurface &right) const; 162 // attached to optical surface. << 140 G4int operator!=(const G4OpticalSurface &right) const; 163 inline G4MaterialPropertiesTable* GetMateria << 141 164 { << 142 public: // With description 165 return theMaterialPropertiesTable; << 143 166 } << 144 //////////////////////////////// 167 << 145 // Constructors and Destructor 168 // Attaches a G4MaterialPropertiesTable to t << 146 //////////////////////////////// 169 inline void SetMaterialPropertiesTable(G4Mat << 147 170 { << 148 G4OpticalSurface(const G4String& name, 171 theMaterialPropertiesTable = anMPT; << 149 G4OpticalSurfaceModel model = glisur, 172 } << 150 G4OpticalSurfaceFinish finish = polished, 173 << 151 G4SurfaceType type = dielectric_dielectric, 174 // Prints information about the optical surf << 152 G4double value = 1.0); 175 void DumpInfo() const; << 153 // Constructor of an optical surface object. 176 << 154 177 // call the correct ReadXXXFile << 155 public: // Without description 178 void ReadDataFile(); << 156 179 << 157 virtual ~G4OpticalSurface(); 180 // read a zlib-compressed file << 158 181 void ReadCompressedFile(const G4String&, std << 159 //////////// 182 << 160 // Methods 183 // Method to read the Look-Up-Table into arr << 161 //////////// 184 void ReadLUTFile(); << 162 185 << 163 // public methods 186 // for DAVIS model << 164 187 inline G4double GetAngularDistributionValue( << 165 public: // With description 188 << 166 189 // Returns the AngularDistributionValue << 167 void SetType(const G4SurfaceType& type); 190 inline G4double GetAngularDistributionValueL << 168 191 << 169 inline G4OpticalSurfaceFinish GetFinish() const { return theFinish; } 192 // Method to read the Davis Look-Up-Table in << 170 // Returns the optical surface finish. 193 void ReadLUTDAVISFile(); << 171 void SetFinish(const G4OpticalSurfaceFinish ); 194 << 172 // Sets the optical surface finish. 195 // Method to read the Look-Up-Table for refl << 173 196 void ReadReflectivityLUTFile(); << 174 inline G4OpticalSurfaceModel GetModel() const { return theModel; } 197 << 175 // Returns the optical surface model used. 198 // Returns the reflectivity value from the D << 176 inline void SetModel(const G4OpticalSurfaceModel model) 199 inline G4double GetReflectivityLUTValue(G4in << 177 { theModel = model; } 200 << 178 // Sets the optical surface model to be followed. 201 // Returns the number of lines in the Davis << 179 202 G4int GetInmax() const; << 180 inline G4double GetSigmaAlpha() const { return sigma_alpha; } 203 << 181 // Returns an unified model surface parameter. 204 // Returns the number of probability values << 182 inline void SetSigmaAlpha(const G4double s_a) { sigma_alpha = s_a; } 205 G4int GetLUTbins() const; << 183 // Sets an unified model surface parameter. 206 << 184 207 // Returns the number of reflectivity values << 185 G4double GetPolish() const { return polish; } 208 G4int GetRefMax() const; << 186 // Returns the optical surface polish type. 209 << 187 inline void SetPolish(const G4double plsh) { polish=plsh; } 210 G4int GetThetaIndexMax() const; << 188 // Sets the optical surface polish type. 211 G4int GetPhiIndexMax() const; << 189 212 << 190 inline G4MaterialPropertiesTable* GetMaterialPropertiesTable() const 213 // Method to read the dichroic surface data << 191 { return theMaterialPropertiesTable; } 214 void ReadDichroicFile(); << 192 // Retrieves the pointer of the G4MaterialPropertiesTable 215 << 193 // attached to optical surface. 216 inline G4Physics2DVector* GetDichroicVector( << 194 217 << 195 inline void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT) 218 private: << 196 { theMaterialPropertiesTable = anMPT; } 219 G4OpticalSurfaceModel theModel; // Surface << 197 // Attaches a G4MaterialPropertiesTable to the optical surface. 220 G4OpticalSurfaceFinish theFinish; // Surfac << 198 221 << 199 void DumpInfo() const; 222 G4double sigma_alpha; // The sigma of micro << 200 // Prints information about the optical surface. 223 G4double polish; // Polish parameter in gli << 201 224 << 202 void ReadLUTFile(void); 225 G4MaterialPropertiesTable* theMaterialProper << 203 // Method to read the Look-Up-Table into array AngularDistribution 226 << 204 227 static const G4int incidentIndexMax = 91; << 205 inline G4double GetAngularDistributionValue(G4int, G4int, G4int); 228 static const G4int thetaIndexMax = 45; << 206 229 static const G4int phiIndexMax = 37; << 207 // for DAVIS model 230 << 208 231 G4float* AngularDistribution; << 209 inline G4double GetAngularDistributionValueLUT(G4int); 232 G4Physics2DVector* DichroicVector; << 210 // Returns the AngularDistributionValue 233 << 211 234 // for DAVIS model << 212 void ReadLUTDAVISFile(void); 235 static const G4int indexmax = 7280001; // 3 << 213 // Method to read the Davis Look-Up-Table into array AngularDistribution 236 static const G4int RefMax = 90; << 214 237 static const G4int LUTbins = 20000; << 215 void ReadReflectivityLUTFile(void); 238 G4float* AngularDistributionLUT; << 216 // Method to read the Look-Up-Table for reflectivity 239 G4float* Reflectivity; << 217 >> 218 inline G4double GetReflectivityLUTValue(G4int); >> 219 // Returns the reflectivity value from the Davis Look-Up-Table >> 220 >> 221 G4int GetInmax(void) const; >> 222 // Returns the number of lines in the Davis Look-Up-Table >> 223 >> 224 G4int GetLUTbins(void) const; >> 225 // Returns the number of probability values per incidentangle >> 226 >> 227 G4int GetRefMax(void) const; >> 228 // Returns the number of reflectivity values per angle >> 229 >> 230 G4int GetThetaIndexMax(void) const; >> 231 G4int GetPhiIndexMax(void) const; >> 232 >> 233 void ReadDichroicFile(void); >> 234 // Method to read the dichroic surface data file into Dichroic >> 235 >> 236 inline G4Physics2DVector* GetDichroicVector(); >> 237 >> 238 private: >> 239 >> 240 // ------------------ >> 241 // Basic data members ( To define an optical surface) >> 242 // ------------------ >> 243 >> 244 G4OpticalSurfaceModel theModel; // Surface model >> 245 G4OpticalSurfaceFinish theFinish; // Surface finish >> 246 >> 247 G4double sigma_alpha; // The sigma of micro-facet polar angle >> 248 G4double polish; // Polish parameter in glisur model >> 249 >> 250 G4MaterialPropertiesTable* theMaterialPropertiesTable; >> 251 >> 252 static const G4int incidentIndexMax = 91; >> 253 static const G4int thetaIndexMax = 45; >> 254 static const G4int phiIndexMax = 37; >> 255 >> 256 G4float* AngularDistribution; >> 257 G4Physics2DVector* DichroicVector; >> 258 >> 259 // for DAVIS model >> 260 static const G4int indexmax = 7280001; // 3640001; >> 261 static const G4int RefMax = 90; >> 262 static const G4int LUTbins =20000; >> 263 G4float* AngularDistributionLUT; >> 264 G4float* Reflectivity; 240 }; 265 }; 241 266 242 //////////////////// 267 //////////////////// 243 // Inline methods 268 // Inline methods 244 //////////////////// 269 //////////////////// 245 270 246 inline G4double G4OpticalSurface::GetAngularDi << 271 inline 247 G4int angleIncident, G4int thetaIndex, G4int << 272 G4double G4OpticalSurface::GetAngularDistributionValue(G4int angleIncident, >> 273 G4int thetaIndex, >> 274 G4int phiIndex) 248 { 275 { 249 G4int product = angleIncident * thetaIndex * << 276 return AngularDistribution[angleIncident+ 250 if (product < 0 || product >= incidentIndexM << 277 thetaIndex*incidentIndexMax+ 251 G4ExceptionDescription ed; << 278 phiIndex*thetaIndexMax*incidentIndexMax]; 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 } 279 } 260 280 261 inline G4double G4OpticalSurface::GetAngularDi << 281 inline >> 282 G4double G4OpticalSurface::GetAngularDistributionValueLUT(G4int i) 262 { 283 { 263 if (i < 0 || i >= indexmax) { << 284 return AngularDistributionLUT[i]; 264 G4ExceptionDescription ed; << 265 ed << "Index " << i << " out of range!"; << 266 G4Exception("G4OpticalSurface::GetAngularD << 267 return 0.; << 268 } << 269 return (G4double)AngularDistributionLUT[i]; << 270 } 285 } 271 286 272 inline G4double G4OpticalSurface::GetReflectiv << 287 inline >> 288 G4double G4OpticalSurface::GetReflectivityLUTValue(G4int i) 273 { 289 { 274 if (i < 0 || i >= RefMax) { << 290 return Reflectivity[i]; 275 G4ExceptionDescription ed; << 276 ed << "Index " << i << " out of range!"; << 277 G4Exception("G4OpticalSurface::GetReflecti << 278 return 0.; << 279 } << 280 return (G4double)Reflectivity[i]; << 281 } 291 } 282 292 283 inline G4Physics2DVector* G4OpticalSurface::Ge << 293 inline >> 294 G4Physics2DVector* G4OpticalSurface::GetDichroicVector() >> 295 { >> 296 return DichroicVector; >> 297 } 284 298 285 #endif /* G4OpticalSurface_h */ 299 #endif /* G4OpticalSurface_h */ 286 300