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