| 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.cc,v 1.4 1999/12/15 14:50:51 gunter 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 // Optical Surface Class Implementation 13 // Optical Surface Class Implementation
28 ////////////////////////////////////////////// 14 ////////////////////////////////////////////////////////////////////////
29 // 15 //
30 // File: G4OpticalSurface.cc 16 // File: G4OpticalSurface.cc
31 // Description: An optical surface class for u 17 // Description: An 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: 2017-02-24 Mariele Stockhoff a << 21 // mail: gum@triumf.ca
>> 22 //
>> 23 // Cvs version:
36 ////////////////////////////////////////////// 24 ////////////////////////////////////////////////////////////////////////
37 25
>> 26 #include "G4ios.hh"
38 #include "G4OpticalSurface.hh" 27 #include "G4OpticalSurface.hh"
39 28
40 #include "globals.hh" << 29 /////////////////////////
41 << 30 // Class Implementation
42 #include <zlib.h> << 31 /////////////////////////
43 << 32
44 #include <fstream> << 33 //////////////
45 #include <iostream> << 34 // Operators
46 << 35 //////////////
47 G4OpticalSurface& G4OpticalSurface::operator=( << 36
48 { << 37 const G4OpticalSurface&
49 if (this != &right) { << 38 G4OpticalSurface::operator=(const G4OpticalSurface& right)
50 theName = right.theName; << 39 {
51 theType = right.theType; << 40 if (this != &right)
52 theModel = right.theModel; << 41 {
53 theFinish = right.theFinish; << 42 theName = right.theName;
54 sigma_alpha = right.sigma_alpha; << 43 theModel = right.theModel;
55 polish = right.polish; << 44 theFinish = right.theFinish;
56 theMaterialPropertiesTable = right.theMate << 45 theType = right.theType;
57 << 46 sigma_alpha = right.sigma_alpha;
58 delete[] AngularDistribution; << 47 polish = right.polish;
59 AngularDistribution = new G4float[incident << 48 theMaterialPropertiesTable = right.theMaterialPropertiesTable;
60 *(AngularDistribution) = *(right.AngularDi << 49 }
61 <<
62 delete[] AngularDistributionLUT; <<
63 AngularDistributionLUT = new G4float[index <<
64 *(AngularDistributionLUT) = *(right.Angula <<
65 <<
66 delete[] Reflectivity; <<
67 Reflectivity = new G4float[RefMax]; <<
68 *(Reflectivity) = *(right.Reflectivity); <<
69 <<
70 delete DichroicVector; <<
71 DichroicVector = new G4Physics2DVector(); <<
72 *DichroicVector = *(right.DichroicVector); <<
73 } <<
74 return *this; 50 return *this;
75 } 51 }
76 52
77 G4OpticalSurface::G4OpticalSurface(const G4Str << 53 /////////////////
78 G4OpticalSurfaceFinish finish, G4SurfaceType << 54 // Constructors
79 : G4SurfaceProperty(name, type), theModel(mo << 55 /////////////////
80 { <<
81 AngularDistribution = nullptr; <<
82 <<
83 AngularDistributionLUT = nullptr; <<
84 Reflectivity = nullptr; <<
85 <<
86 DichroicVector = nullptr; <<
87 56
88 switch (theModel) { << 57 G4OpticalSurface::G4OpticalSurface(const G4String& name,
89 case glisur: << 58 G4OpticalSurfaceModel model,
90 polish = value; << 59 G4OpticalSurfaceFinish finish,
91 sigma_alpha = 0.0; << 60 G4OpticalSurfaceType type,
92 break; << 61 G4double value)
93 case LUT: << 62 : theName(name),
94 case dichroic: << 63 theModel(model),
95 case DAVIS: << 64 theFinish(finish),
96 ReadDataFile(); << 65 theType(type),
97 // fall through << 66 theMaterialPropertiesTable(NULL)
98 case unified: <<
99 sigma_alpha = value; <<
100 polish = 0.0; <<
101 break; <<
102 default: <<
103 G4Exception("G4OpticalSurface::G4Optical <<
104 "Constructor called with INVALID model <<
105 } <<
106 } <<
107 <<
108 G4OpticalSurface::~G4OpticalSurface() <<
109 { 67 {
110 delete[] AngularDistribution; << 68 if (model == glisur ){
111 << 69 polish = value;
112 delete[] AngularDistributionLUT; << 70 sigma_alpha = 0.0;
113 << 71 }
114 delete[] Reflectivity; << 72 else if ( model == unified ) {
115 << 73 sigma_alpha = value;
116 delete DichroicVector; << 74 polish = 0.0;
>> 75 }
>> 76 else {
>> 77 G4Exception("G4OpticalSurface::G4OpticalSurface ==> "
>> 78 "Constructor called with INVALID model.");
>> 79 }
117 } 80 }
118 81
119 G4OpticalSurface::G4OpticalSurface(const G4Opt << 82 G4OpticalSurface::G4OpticalSurface(const G4OpticalSurface &right)
120 : G4SurfaceProperty(right.theName, right.the <<
121 { 83 {
122 *this = right; << 84 *this = right;
123 this->theName = right.theName; <<
124 this->theType = right.theType; <<
125 this->theModel = right.theModel; <<
126 this->theFinish = right.theFinish; <<
127 this->sigma_alpha = right.sigma_alpha; <<
128 this->polish = right.polish; <<
129 this->theMaterialPropertiesTable = right.the <<
130 <<
131 delete[] AngularDistribution; <<
132 this->AngularDistribution = new G4float[inci <<
133 *(this->AngularDistribution) = *(right.Angul <<
134 <<
135 delete[] AngularDistributionLUT; <<
136 this->AngularDistributionLUT = new G4float[i <<
137 *(this->AngularDistributionLUT) = *(right.An <<
138 <<
139 delete[] Reflectivity; <<
140 this->Reflectivity = new G4float[RefMax]; <<
141 *(this->Reflectivity) = *(right.Reflectivity <<
142 <<
143 delete DichroicVector; <<
144 this->DichroicVector = new G4Physics2DVector <<
145 *(this->DichroicVector) = *(right.DichroicVe <<
146 } 85 }
147 86
148 G4bool G4OpticalSurface::operator==(const G4Op << 87 G4OpticalSurface::~G4OpticalSurface(){}
149 { <<
150 return (this == (G4OpticalSurface*)&right); <<
151 } <<
152 88
153 G4bool G4OpticalSurface::operator!=(const G4Op << 89 G4int G4OpticalSurface::operator==(const G4OpticalSurface &right) const
154 { 90 {
155 return (this != (G4OpticalSurface*)&right); << 91 return (this == (G4OpticalSurface *) &right);
156 } 92 }
157 93
158 G4int G4OpticalSurface::GetInmax() const { ret << 94 G4int G4OpticalSurface::operator!=(const G4OpticalSurface &right) const
159 <<
160 G4int G4OpticalSurface::GetLUTbins() const { r <<
161 <<
162 G4int G4OpticalSurface::GetRefMax() const { re <<
163 <<
164 G4int G4OpticalSurface::GetThetaIndexMax() con <<
165 <<
166 G4int G4OpticalSurface::GetPhiIndexMax() const <<
167 <<
168 void G4OpticalSurface::DumpInfo() const <<
169 { 95 {
170 // Dump info for surface << 96 return (this != (G4OpticalSurface *) &right);
171 <<
172 G4cout << " Surface type = " << G4int(the <<
173 << " Surface finish = " << G4int(the <<
174 << " Surface model = " << G4int(the <<
175 << G4endl << " ----------------- " < <<
176 <<
177 if (theModel == glisur) { <<
178 G4cout << " polish: " << polish << G4endl; <<
179 } <<
180 else { <<
181 G4cout << " sigma_alpha: " << sigma_alpha <<
182 } <<
183 G4cout << G4endl; <<
184 } <<
185 <<
186 void G4OpticalSurface::SetType(const G4Surface <<
187 { <<
188 theType = type; <<
189 ReadDataFile(); <<
190 } <<
191 <<
192 void G4OpticalSurface::SetFinish(const G4Optic <<
193 { <<
194 theFinish = finish; <<
195 ReadDataFile(); <<
196 } <<
197 <<
198 void G4OpticalSurface::ReadDataFile() <<
199 { <<
200 // type and finish can be set in either orde <<
201 // for consistency. Need to read file on set <<
202 switch (theType) { <<
203 case dielectric_LUT: <<
204 if (AngularDistribution == nullptr) { <<
205 AngularDistribution = new G4float[inci <<
206 } <<
207 ReadLUTFile(); <<
208 break; <<
209 case dielectric_LUTDAVIS: <<
210 if (AngularDistributionLUT == nullptr) { <<
211 AngularDistributionLUT = new G4float[i <<
212 } <<
213 ReadLUTDAVISFile(); <<
214 <<
215 if (Reflectivity == nullptr) { <<
216 Reflectivity = new G4float[RefMax]; <<
217 } <<
218 ReadReflectivityLUTFile(); <<
219 break; <<
220 case dielectric_dichroic: <<
221 if (DichroicVector == nullptr) { <<
222 DichroicVector = new G4Physics2DVector <<
223 } <<
224 ReadDichroicFile(); <<
225 break; <<
226 default: <<
227 break; <<
228 } <<
229 } <<
230 <<
231 void G4OpticalSurface::ReadLUTFile() <<
232 { <<
233 G4String readLUTFileName; <<
234 <<
235 switch (theFinish) { <<
236 case polishedlumirrorglue: <<
237 readLUTFileName = "PolishedLumirrorGlue. <<
238 break; <<
239 case polishedlumirrorair: <<
240 readLUTFileName = "PolishedLumirror.z"; <<
241 break; <<
242 case polishedteflonair: <<
243 readLUTFileName = "PolishedTeflon.z"; <<
244 break; <<
245 case polishedtioair: <<
246 readLUTFileName = "PolishedTiO.z"; <<
247 break; <<
248 case polishedtyvekair: <<
249 readLUTFileName = "PolishedTyvek.z"; <<
250 break; <<
251 case polishedvm2000glue: <<
252 readLUTFileName = "PolishedVM2000Glue.z" <<
253 break; <<
254 case polishedvm2000air: <<
255 readLUTFileName = "PolishedVM2000.z"; <<
256 break; <<
257 case etchedlumirrorglue: <<
258 readLUTFileName = "EtchedLumirrorGlue.z" <<
259 break; <<
260 case etchedlumirrorair: <<
261 readLUTFileName = "EtchedLumirror.z"; <<
262 break; <<
263 case etchedteflonair: <<
264 readLUTFileName = "EtchedTeflon.z"; <<
265 break; <<
266 case etchedtioair: <<
267 readLUTFileName = "EtchedTiO.z"; <<
268 break; <<
269 case etchedtyvekair: <<
270 readLUTFileName = "EtchedTyvek.z"; <<
271 break; <<
272 case etchedvm2000glue: <<
273 readLUTFileName = "EtchedVM2000Glue.z"; <<
274 break; <<
275 case etchedvm2000air: <<
276 readLUTFileName = "EtchedVM2000.z"; <<
277 break; <<
278 case groundlumirrorglue: <<
279 readLUTFileName = "GroundLumirrorGlue.z" <<
280 break; <<
281 case groundlumirrorair: <<
282 readLUTFileName = "GroundLumirror.z"; <<
283 break; <<
284 case groundteflonair: <<
285 readLUTFileName = "GroundTeflon.z"; <<
286 break; <<
287 case groundtioair: <<
288 readLUTFileName = "GroundTiO.z"; <<
289 break; <<
290 case groundtyvekair: <<
291 readLUTFileName = "GroundTyvek.z"; <<
292 break; <<
293 case groundvm2000glue: <<
294 readLUTFileName = "GroundVM2000Glue.z"; <<
295 break; <<
296 case groundvm2000air: <<
297 readLUTFileName = "GroundVM2000.z"; <<
298 break; <<
299 default: <<
300 return; <<
301 } <<
302 <<
303 std::istringstream iss; <<
304 ReadCompressedFile(readLUTFileName, iss); <<
305 <<
306 size_t idxmax = incidentIndexMax * thetaInde <<
307 for (size_t i = 0; i < idxmax; ++i) { <<
308 iss >> AngularDistribution[i]; <<
309 } <<
310 G4cout << "LUT - data file: " << readLUTFile <<
311 } 97 }
>> 98 ////////////
>> 99 // Methods
>> 100 ////////////
312 101
313 void G4OpticalSurface::ReadLUTDAVISFile() << 102 void G4OpticalSurface::DumpInfo() const
314 { 103 {
315 G4String readLUTDAVISFileName; <<
316 104
317 switch (theFinish) { << 105 // Dump info for surface
318 case Rough_LUT: <<
319 readLUTDAVISFileName = "Rough_LUT.z"; <<
320 break; <<
321 case RoughTeflon_LUT: <<
322 readLUTDAVISFileName = "RoughTeflon_LUT. <<
323 break; <<
324 case RoughESR_LUT: <<
325 readLUTDAVISFileName = "RoughESR_LUT.z"; <<
326 break; <<
327 case RoughESRGrease_LUT: <<
328 readLUTDAVISFileName = "RoughESRGrease_L <<
329 break; <<
330 case Polished_LUT: <<
331 readLUTDAVISFileName = "Polished_LUT.z"; <<
332 break; <<
333 case PolishedTeflon_LUT: <<
334 readLUTDAVISFileName = "PolishedTeflon_L <<
335 break; <<
336 case PolishedESR_LUT: <<
337 readLUTDAVISFileName = "PolishedESR_LUT. <<
338 break; <<
339 case PolishedESRGrease_LUT: <<
340 readLUTDAVISFileName = "PolishedESRGreas <<
341 break; <<
342 case Detector_LUT: <<
343 readLUTDAVISFileName = "Detector_LUT.z"; <<
344 break; <<
345 default: <<
346 return; <<
347 } <<
348 <<
349 std::istringstream iss; <<
350 ReadCompressedFile(readLUTDAVISFileName, iss <<
351 <<
352 for (size_t i = 0; i < indexmax; ++i) { <<
353 iss >> AngularDistributionLUT[i]; <<
354 } <<
355 G4cout << "LUT DAVIS - data file: " << readL <<
356 } <<
357 106
358 void G4OpticalSurface::ReadReflectivityLUTFile << 107 G4cout <<
359 { << 108 " Surface type = " << theType << G4endl <<
360 G4String readReflectivityLUTFileName; << 109 " Surface finish = " << theFinish << G4endl <<
>> 110 " Surface model = " << theModel << G4endl;
361 111
362 switch (theFinish) { << 112 G4cout << G4endl;
363 case Rough_LUT: <<
364 readReflectivityLUTFileName = "Rough_LUT <<
365 break; <<
366 case RoughTeflon_LUT: <<
367 readReflectivityLUTFileName = "RoughTefl <<
368 break; <<
369 case RoughESR_LUT: <<
370 readReflectivityLUTFileName = "RoughESR_ <<
371 break; <<
372 case RoughESRGrease_LUT: <<
373 readReflectivityLUTFileName = "RoughESRG <<
374 break; <<
375 case Polished_LUT: <<
376 readReflectivityLUTFileName = "Polished_ <<
377 break; <<
378 case PolishedTeflon_LUT: <<
379 readReflectivityLUTFileName = "PolishedT <<
380 break; <<
381 case PolishedESR_LUT: <<
382 readReflectivityLUTFileName = "PolishedE <<
383 break; <<
384 case PolishedESRGrease_LUT: <<
385 readReflectivityLUTFileName = "PolishedE <<
386 break; <<
387 case Detector_LUT: <<
388 readReflectivityLUTFileName = "Detector_ <<
389 break; <<
390 default: <<
391 return; <<
392 } <<
393 <<
394 std::istringstream iss; <<
395 ReadCompressedFile(readReflectivityLUTFileNa <<
396 <<
397 for (size_t i = 0; i < RefMax; ++i) { <<
398 iss >> Reflectivity[i]; <<
399 } <<
400 G4cout << "LUT DAVIS - reflectivity data fil <<
401 << G4endl; <<
402 } <<
403 <<
404 // uncompress one data file into the input str <<
405 void G4OpticalSurface::ReadCompressedFile(cons <<
406 { <<
407 G4String* dataString = nullptr; <<
408 G4String path = G4FindDataDir("G4REALSURFACE <<
409 G4String compfilename = path + "/" + filenam <<
410 // create input stream with binary mode oper <<
411 std::ifstream in(compfilename, std::ios::bin <<
412 if (in.good()) { <<
413 // get current position in the stream (was <<
414 G4int fileSize = (G4int)in.tellg(); <<
415 // set current position being the beginnin <<
416 in.seekg(0, std::ios::beg); <<
417 // create (zlib) byte buffer for the data <<
418 auto compdata = new Bytef[fileSize]; <<
419 while (in) { <<
420 in.read((char*)compdata, fileSize); <<
421 } <<
422 // create (zlib) byte buffer for the uncom <<
423 auto complen = (uLongf)(fileSize * 4); <<
424 auto uncompdata = new Bytef[complen]; <<
425 while (Z_OK != uncompress(uncompdata, &com <<
426 // increase uncompressed byte buffer <<
427 delete[] uncompdata; <<
428 complen *= 2; <<
429 uncompdata = new Bytef[complen]; <<
430 } <<
431 // delete the compressed data buffer <<
432 delete[] compdata; <<
433 // create a string from uncompressed data <<
434 dataString = new G4String((char*)uncompdat <<
435 // delete the uncompressed data buffer <<
436 delete[] uncompdata; <<
437 } <<
438 else { <<
439 G4ExceptionDescription ed; <<
440 ed << "Problem while trying to read " + co <<
441 G4Exception("G4OpticalSurface::ReadCompres <<
442 return; <<
443 } <<
444 // create the input string stream from the d <<
445 if (dataString != nullptr) { <<
446 iss.str(*dataString); <<
447 in.close(); <<
448 delete dataString; <<
449 G4cout << "G4OpticalSurface: data file " < <<
450 } <<
451 } <<
452 <<
453 void G4OpticalSurface::ReadDichroicFile() <<
454 { <<
455 const char* datadir = G4FindDataDir("G4DICHR <<
456 113
457 if (datadir == nullptr) { << 114 G4cout << " Surface parameter " << G4endl;
458 G4Exception("G4OpticalSurface::ReadDichroi << 115 G4cout << " ----------------- " << G4endl;
459 "Environment variable G4DICHROICDATA not << 116 if (theModel == glisur ){
460 return; << 117 G4cout << polish << G4endl;
461 } << 118 }
462 << 119 else {
463 std::ostringstream ost; << 120 G4cout << sigma_alpha << G4endl;
464 ost << datadir; << 121 }
465 std::ifstream fin(ost.str().c_str()); << 122 G4cout << G4endl;
466 if (! fin.is_open()) { <<
467 G4ExceptionDescription ed; <<
468 ed << "Dichroic surface data file <" << os <<
469 G4Exception("G4OpticalSurface::ReadDichroi <<
470 return; <<
471 } <<
472 <<
473 if (! (DichroicVector->Retrieve(fin))) { <<
474 G4ExceptionDescription ed; <<
475 ed << "Dichroic surface data file <" << os <<
476 G4Exception("G4OpticalSurface::ReadDichroi <<
477 return; <<
478 } <<
479 <<
480 // DichroicVector->SetBicubicInterpolation( <<
481 <<
482 G4cout << " *** Dichroic surface data file * <<
483 <<
484 auto numberOfXNodes = (G4int)DichroicVector- <<
485 auto numberOfYNodes = (G4int)DichroicVector- <<
486 <<
487 G4cout << "numberOfXNodes: " << numberOfXNod <<
488 G4cout << "numberOfYNodes: " << numberOfYNod <<
489 <<
490 if (0 > numberOfXNodes || numberOfXNodes >= <<
491 numberOfXNodes = 0; <<
492 } <<
493 if (0 > numberOfYNodes || numberOfYNodes >= <<
494 numberOfYNodes = 0; <<
495 } <<
496 <<
497 G4PV2DDataVector xVector; <<
498 G4PV2DDataVector yVector; <<
499 <<
500 xVector.resize(numberOfXNodes, 0.); <<
501 yVector.resize(numberOfYNodes, 0.); <<
502 <<
503 for (G4int i = 0; i < numberOfXNodes; ++i) { <<
504 G4cout << "i: " << DichroicVector->GetX(i) <<
505 xVector[i] = DichroicVector->GetX(i); <<
506 } <<
507 for (G4int j = 0; j < numberOfYNodes; ++j) { <<
508 G4cout << "j: " << DichroicVector->GetY(j) <<
509 yVector[j] = DichroicVector->GetY(j); <<
510 } <<
511 <<
512 for (G4int j = 0; j < numberOfYNodes; ++j) { <<
513 for (G4int i = 0; i < numberOfXNodes; ++i) <<
514 G4cout << " i: " << i << " j: " << j << <<
515 } <<
516 } <<
517 } 123 }
518 124