| 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.cc,v 1.9 2003/12/01 15:13:41 gcosmo Exp $
>> 25 // GEANT4 tag $Name: geant4-06-00-patch-01 $
>> 26 //
>> 27 //
26 ////////////////////////////////////////////// 28 ////////////////////////////////////////////////////////////////////////
27 // Optical Surface Class Implementation 29 // Optical Surface Class Implementation
28 ////////////////////////////////////////////// 30 ////////////////////////////////////////////////////////////////////////
29 // 31 //
30 // File: G4OpticalSurface.cc 32 // File: G4OpticalSurface.cc
31 // Description: An optical surface class for u 33 // Description: An 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: 2017-02-24 Mariele Stockhoff a << 37 // mail: gum@triumf.ca
>> 38 //
36 ////////////////////////////////////////////// 39 ////////////////////////////////////////////////////////////////////////
37 40
38 #include "G4OpticalSurface.hh" << 41 #include "G4ios.hh"
39 <<
40 #include "globals.hh" 42 #include "globals.hh"
>> 43 #include "G4OpticalSurface.hh"
41 44
42 #include <zlib.h> << 45 /////////////////////////
43 << 46 // Class Implementation
44 #include <fstream> << 47 /////////////////////////
45 #include <iostream> << 48
46 << 49 //////////////
47 G4OpticalSurface& G4OpticalSurface::operator=( << 50 // Operators
48 { << 51 //////////////
49 if (this != &right) { << 52
50 theName = right.theName; << 53 const G4OpticalSurface&
51 theType = right.theType; << 54 G4OpticalSurface::operator=(const G4OpticalSurface& right)
52 theModel = right.theModel; << 55 {
53 theFinish = right.theFinish; << 56 if (this != &right)
54 sigma_alpha = right.sigma_alpha; << 57 {
55 polish = right.polish; << 58 theName = right.GetName();
56 theMaterialPropertiesTable = right.theMate << 59 theModel = right.theModel;
57 << 60 theFinish = right.theFinish;
58 delete[] AngularDistribution; << 61 theType = right.GetType();
59 AngularDistribution = new G4float[incident << 62 sigma_alpha = right.sigma_alpha;
60 *(AngularDistribution) = *(right.AngularDi << 63 polish = right.polish;
61 << 64 theMaterialPropertiesTable = right.theMaterialPropertiesTable;
62 delete[] AngularDistributionLUT; << 65 }
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; 66 return *this;
75 } 67 }
76 68
77 G4OpticalSurface::G4OpticalSurface(const G4Str << 69 /////////////////
78 G4OpticalSurfaceFinish finish, G4SurfaceType << 70 // Constructors
79 : G4SurfaceProperty(name, type), theModel(mo << 71 /////////////////
80 { <<
81 AngularDistribution = nullptr; <<
82 <<
83 AngularDistributionLUT = nullptr; <<
84 Reflectivity = nullptr; <<
85 <<
86 DichroicVector = nullptr; <<
87 <<
88 switch (theModel) { <<
89 case glisur: <<
90 polish = value; <<
91 sigma_alpha = 0.0; <<
92 break; <<
93 case LUT: <<
94 case dichroic: <<
95 case DAVIS: <<
96 ReadDataFile(); <<
97 // fall through <<
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 { <<
110 delete[] AngularDistribution; <<
111 <<
112 delete[] AngularDistributionLUT; <<
113 <<
114 delete[] Reflectivity; <<
115 <<
116 delete DichroicVector; <<
117 } <<
118 <<
119 G4OpticalSurface::G4OpticalSurface(const G4Opt <<
120 : G4SurfaceProperty(right.theName, right.the <<
121 { <<
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 } <<
147 <<
148 G4bool G4OpticalSurface::operator==(const G4Op <<
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 72
168 void G4OpticalSurface::DumpInfo() const << 73 G4OpticalSurface::G4OpticalSurface(const G4String& name,
>> 74 G4OpticalSurfaceModel model,
>> 75 G4OpticalSurfaceFinish finish,
>> 76 G4SurfaceType type,
>> 77 G4double value)
>> 78 : G4SurfaceProperty(name,type),
>> 79 theModel(model),
>> 80 theFinish(finish),
>> 81 theMaterialPropertiesTable(0)
169 { 82 {
170 // Dump info for surface << 83 if (model == glisur ){
171 << 84 polish = value;
172 G4cout << " Surface type = " << G4int(the << 85 sigma_alpha = 0.0;
173 << " Surface finish = " << G4int(the << 86 }
174 << " Surface model = " << G4int(the << 87 else if ( model == unified ) {
175 << G4endl << " ----------------- " < << 88 sigma_alpha = value;
176 << 89 polish = 0.0;
177 if (theModel == glisur) { << 90 }
178 G4cout << " polish: " << polish << G4endl; << 91 else {
179 } << 92 G4Exception("G4OpticalSurface::G4OpticalSurface ==> "
180 else { << 93 "Constructor called with INVALID model.");
181 G4cout << " sigma_alpha: " << sigma_alpha << 94 }
182 } <<
183 G4cout << G4endl; <<
184 } <<
185 <<
186 void G4OpticalSurface::SetType(const G4Surface <<
187 { <<
188 theType = type; <<
189 ReadDataFile(); <<
190 } 95 }
191 96
192 void G4OpticalSurface::SetFinish(const G4Optic << 97 G4OpticalSurface::G4OpticalSurface(const G4OpticalSurface &right)
>> 98 : G4SurfaceProperty(right.GetName())
193 { 99 {
194 theFinish = finish; << 100 *this = right;
195 ReadDataFile(); <<
196 } 101 }
197 102
198 void G4OpticalSurface::ReadDataFile() << 103 G4OpticalSurface::~G4OpticalSurface(){}
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 104
231 void G4OpticalSurface::ReadLUTFile() << 105 G4int G4OpticalSurface::operator==(const G4OpticalSurface &right) const
232 { 106 {
233 G4String readLUTFileName; << 107 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 } 108 }
312 109
313 void G4OpticalSurface::ReadLUTDAVISFile() << 110 G4int G4OpticalSurface::operator!=(const G4OpticalSurface &right) const
314 { 111 {
315 G4String readLUTDAVISFileName; << 112 return (this != (G4OpticalSurface *) &right);
316 <<
317 switch (theFinish) { <<
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 } 113 }
>> 114 ////////////
>> 115 // Methods
>> 116 ////////////
357 117
358 void G4OpticalSurface::ReadReflectivityLUTFile << 118 void G4OpticalSurface::DumpInfo() const
359 { 119 {
360 G4String readReflectivityLUTFileName; <<
361 120
362 switch (theFinish) { << 121 // Dump info for surface
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 122
404 // uncompress one data file into the input str << 123 G4cout <<
405 void G4OpticalSurface::ReadCompressedFile(cons << 124 " Surface type = " << G4int(theType) << G4endl <<
406 { << 125 " Surface finish = " << G4int(theFinish) << G4endl <<
407 G4String* dataString = nullptr; << 126 " Surface model = " << G4int(theModel) << G4endl;
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 127
453 void G4OpticalSurface::ReadDichroicFile() << 128 G4cout << G4endl;
454 { <<
455 const char* datadir = G4FindDataDir("G4DICHR <<
456 129
457 if (datadir == nullptr) { << 130 G4cout << " Surface parameter " << G4endl;
458 G4Exception("G4OpticalSurface::ReadDichroi << 131 G4cout << " ----------------- " << G4endl;
459 "Environment variable G4DICHROICDATA not << 132 if (theModel == glisur ){
460 return; << 133 G4cout << polish << G4endl;
461 } << 134 }
462 << 135 else {
463 std::ostringstream ost; << 136 G4cout << sigma_alpha << G4endl;
464 ost << datadir; << 137 }
465 std::ifstream fin(ost.str().c_str()); << 138 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 } 139 }
518 140