| 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.cc,v 1.12 2008/12/11 10:23:54 gcosmo Exp $
>> 28 // GEANT4 tag $Name: geant4-09-02-patch-03 $
>> 29 //
>> 30 //
26 ////////////////////////////////////////////// 31 ////////////////////////////////////////////////////////////////////////
27 // Optical Surface Class Implementation 32 // Optical Surface Class Implementation
28 ////////////////////////////////////////////// 33 ////////////////////////////////////////////////////////////////////////
29 // 34 //
30 // File: G4OpticalSurface.cc 35 // File: G4OpticalSurface.cc
31 // Description: An optical surface class for u 36 // Description: An 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: 2017-02-24 Mariele Stockhoff a << 40 // mail: gum@triumf.ca
>> 41 //
36 ////////////////////////////////////////////// 42 ////////////////////////////////////////////////////////////////////////
37 43
38 #include "G4OpticalSurface.hh" << 44 #include "G4ios.hh"
39 <<
40 #include "globals.hh" 45 #include "globals.hh"
>> 46 #include "G4OpticalSurface.hh"
41 47
42 #include <zlib.h> << 48 /////////////////////////
43 << 49 // Class Implementation
44 #include <fstream> << 50 /////////////////////////
45 #include <iostream> << 51
46 << 52 //////////////
47 G4OpticalSurface& G4OpticalSurface::operator=( << 53 // Operators
48 { << 54 //////////////
49 if (this != &right) { << 55
50 theName = right.theName; << 56 const G4OpticalSurface&
51 theType = right.theType; << 57 G4OpticalSurface::operator=(const G4OpticalSurface& right)
52 theModel = right.theModel; << 58 {
53 theFinish = right.theFinish; << 59 if (this != &right)
54 sigma_alpha = right.sigma_alpha; << 60 {
55 polish = right.polish; << 61 theName = right.GetName();
56 theMaterialPropertiesTable = right.theMate << 62 theModel = right.theModel;
57 << 63 theFinish = right.theFinish;
58 delete[] AngularDistribution; << 64 theType = right.GetType();
59 AngularDistribution = new G4float[incident << 65 sigma_alpha = right.sigma_alpha;
60 *(AngularDistribution) = *(right.AngularDi << 66 polish = right.polish;
61 << 67 theMaterialPropertiesTable = right.theMaterialPropertiesTable;
62 delete[] AngularDistributionLUT; << 68 }
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; 69 return *this;
75 } 70 }
76 71
77 G4OpticalSurface::G4OpticalSurface(const G4Str << 72 /////////////////
78 G4OpticalSurfaceFinish finish, G4SurfaceType << 73 // Constructors
79 : G4SurfaceProperty(name, type), theModel(mo << 74 /////////////////
80 { << 75
81 AngularDistribution = nullptr; << 76 G4OpticalSurface::G4OpticalSurface(const G4String& name,
82 << 77 G4OpticalSurfaceModel model,
83 AngularDistributionLUT = nullptr; << 78 G4OpticalSurfaceFinish finish,
84 Reflectivity = nullptr; << 79 G4SurfaceType type,
85 << 80 G4double value)
86 DichroicVector = nullptr; << 81 : G4SurfaceProperty(name,type),
87 << 82 theModel(model),
88 switch (theModel) { << 83 theFinish(finish),
89 case glisur: << 84 theMaterialPropertiesTable(0)
90 polish = value; << 85 {
91 sigma_alpha = 0.0; << 86 if (model == glisur ){
92 break; << 87 polish = value;
93 case LUT: << 88 sigma_alpha = 0.0;
94 case dichroic: << 89 }
95 case DAVIS: << 90 else if ( model == unified ) {
96 ReadDataFile(); << 91 sigma_alpha = value;
97 // fall through << 92 polish = 0.0;
98 case unified: << 93 }
99 sigma_alpha = value; << 94 else {
100 polish = 0.0; << 95 G4Exception("G4OpticalSurface::G4OpticalSurface ==> "
101 break; << 96 "Constructor called with INVALID model.");
102 default: << 97 }
103 G4Exception("G4OpticalSurface::G4Optical <<
104 "Constructor called with INVALID model <<
105 } <<
106 } <<
107 <<
108 G4OpticalSurface::~G4OpticalSurface() <<
109 { <<
110 delete[] AngularDistribution; <<
111 <<
112 delete[] AngularDistributionLUT; <<
113 <<
114 delete[] Reflectivity; <<
115 <<
116 delete DichroicVector; <<
117 } 98 }
118 99
119 G4OpticalSurface::G4OpticalSurface(const G4Opt << 100 G4OpticalSurface::G4OpticalSurface()
120 : G4SurfaceProperty(right.theName, right.the << 101 : G4SurfaceProperty()
121 { 102 {
122 *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 } 103 }
147 104
148 G4bool G4OpticalSurface::operator==(const G4Op << 105 G4OpticalSurface::~G4OpticalSurface()
149 { <<
150 return (this == (G4OpticalSurface*)&right); <<
151 } <<
152 <<
153 G4bool G4OpticalSurface::operator!=(const G4Op <<
154 { <<
155 return (this != (G4OpticalSurface*)&right); <<
156 } <<
157 <<
158 G4int G4OpticalSurface::GetInmax() const { ret <<
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 { <<
170 // Dump info for surface <<
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 { 106 {
188 theType = type; <<
189 ReadDataFile(); <<
190 } 107 }
191 108
192 void G4OpticalSurface::SetFinish(const G4Optic << 109 G4OpticalSurface::G4OpticalSurface(const G4OpticalSurface &right)
>> 110 : G4SurfaceProperty(right.GetName())
193 { 111 {
194 theFinish = finish; << 112 *this = right;
195 ReadDataFile(); <<
196 } 113 }
197 114
198 void G4OpticalSurface::ReadDataFile() << 115 G4int G4OpticalSurface::operator==(const G4OpticalSurface &right) const
199 { 116 {
200 // type and finish can be set in either orde << 117 return (this == (G4OpticalSurface *) &right);
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 } 118 }
230 119
231 void G4OpticalSurface::ReadLUTFile() << 120 G4int G4OpticalSurface::operator!=(const G4OpticalSurface &right) const
232 { 121 {
233 G4String readLUTFileName; << 122 return (this != (G4OpticalSurface *) &right);
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 } 123 }
>> 124 ////////////
>> 125 // Methods
>> 126 ////////////
312 127
313 void G4OpticalSurface::ReadLUTDAVISFile() << 128 void G4OpticalSurface::DumpInfo() const
314 { 129 {
315 G4String readLUTDAVISFileName; <<
316 130
317 switch (theFinish) { << 131 // 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 132
358 void G4OpticalSurface::ReadReflectivityLUTFile << 133 G4cout <<
359 { << 134 " Surface type = " << G4int(theType) << G4endl <<
360 G4String readReflectivityLUTFileName; << 135 " Surface finish = " << G4int(theFinish) << G4endl <<
>> 136 " Surface model = " << G4int(theModel) << G4endl;
361 137
362 switch (theFinish) { << 138 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 139
457 if (datadir == nullptr) { << 140 G4cout << " Surface parameter " << G4endl;
458 G4Exception("G4OpticalSurface::ReadDichroi << 141 G4cout << " ----------------- " << G4endl;
459 "Environment variable G4DICHROICDATA not << 142 if (theModel == glisur ){
460 return; << 143 G4cout << polish << G4endl;
461 } << 144 }
462 << 145 else {
463 std::ostringstream ost; << 146 G4cout << sigma_alpha << G4endl;
464 ost << datadir; << 147 }
465 std::ifstream fin(ost.str().c_str()); << 148 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 } 149 }
518 150