| 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 // 26 //
27 // ------------------------------------------- 27 // --------------------------------------------------------------
28 // GEANT 4 - ULTRA experiment 28 // GEANT 4 - ULTRA experiment example
29 // ------------------------------------------- 29 // --------------------------------------------------------------
30 // 30 //
31 // Code developed by: 31 // Code developed by:
32 // B. Tome, M.C. Espirito-Santo, A. Trindade, << 32 // B. Tome, M.C. Espirito-Santo, A. Trindade, P. Rodrigues
33 // 33 //
34 // **************************************** 34 // ****************************************************
35 // * UltraDetectorConstruction.cc 35 // * UltraDetectorConstruction.cc
36 // **************************************** 36 // ****************************************************
37 // 37 //
38 // Class used in the definition of the Ultr 38 // Class used in the definition of the Ultra setup consisting of:
39 // - the UVscope detector 39 // - the UVscope detector
40 // - an optional reflecting surface 40 // - an optional reflecting surface
41 // Optical photons can reach the UVscope ei 41 // Optical photons can reach the UVscope either directly or after reflection in the
42 // surface, which can be polished or diffus 42 // surface, which can be polished or diffusing.
43 // The main part of the UVscope definition 43 // The main part of the UVscope definition is the Fresnel lens construction based
44 // on the UltraFresnelLens class. 44 // on the UltraFresnelLens class.
45 // 45 //
46 #include <cmath> 46 #include <cmath>
47 <<
48 #include "UltraDetectorConstruction.hh" 47 #include "UltraDetectorConstruction.hh"
49 #include "UltraDetectorMessenger.hh" <<
50 #include "UltraPMTSD.hh" 48 #include "UltraPMTSD.hh"
51 #include "UltraFresnelLens.hh" 49 #include "UltraFresnelLens.hh"
52 50
53 #include "G4PhysicalConstants.hh" << 51 #include "G4SDManager.hh"
54 #include "G4SystemOfUnits.hh" <<
55 #include "G4RunManager.hh" <<
56 #include "G4MTRunManager.hh" <<
57 #include "G4GeometryManager.hh" <<
58 #include "G4Material.hh" 52 #include "G4Material.hh"
59 #include "G4MaterialTable.hh" 53 #include "G4MaterialTable.hh"
60 #include "G4Element.hh" 54 #include "G4Element.hh"
61 #include "G4ElementTable.hh" 55 #include "G4ElementTable.hh"
62 #include "G4LogicalBorderSurface.hh" 56 #include "G4LogicalBorderSurface.hh"
63 #include "G4LogicalSkinSurface.hh" <<
64 #include "G4Box.hh" 57 #include "G4Box.hh"
65 #include "G4Sphere.hh" 58 #include "G4Sphere.hh"
66 #include "G4Tubs.hh" 59 #include "G4Tubs.hh"
67 #include "G4LogicalVolume.hh" 60 #include "G4LogicalVolume.hh"
68 #include "G4RotationMatrix.hh" 61 #include "G4RotationMatrix.hh"
69 #include "G4ThreeVector.hh" 62 #include "G4ThreeVector.hh"
70 #include "G4Transform3D.hh" 63 #include "G4Transform3D.hh"
71 #include "G4PVPlacement.hh" 64 #include "G4PVPlacement.hh"
72 #include "G4OpBoundaryProcess.hh" 65 #include "G4OpBoundaryProcess.hh"
73 #include "G4VisAttributes.hh" 66 #include "G4VisAttributes.hh"
74 #include "G4Colour.hh" 67 #include "G4Colour.hh"
75 #include "G4Log.hh" <<
76 #include "G4SDManager.hh" <<
77 68
78 //....oooOO0OOooo........oooOO0OOooo........oo 69 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
79 70
80 UltraDetectorConstruction::UltraDetectorConstr << 71 UltraDetectorConstruction::UltraDetectorConstruction()
81 fReflectorOpticalSurface(0), <<
82 logicalPMT(0), <<
83 fReflectorLog(0), <<
84 fIsReflectorConstructed(false) <<
85 { 72 {
86 // Define wavelength limits for materials de <<
87 lambda_min = 200*nm ; <<
88 lambda_max = 700*nm ; <<
89 73
90 fDetectorMessenger = new UltraDetectorMessen << 74 PMTSD = 0;
>> 75
>> 76 // Sensitive Detector Manager
>> 77 SDmanager = G4SDManager::GetSDMpointer();
>> 78
>> 79 // Define wavelength limits for materials definition
>> 80 lambda_min = 200*nm ;
>> 81 lambda_max = 700*nm ;
91 82
92 ConstructTableMaterials(); <<
93 } 83 }
94 84
95 //....oooOO0OOooo........oooOO0OOooo........oo 85 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
96 86
97 UltraDetectorConstruction::~UltraDetectorConst << 87 UltraDetectorConstruction::~UltraDetectorConstruction(){;}
98 { <<
99 delete fDetectorMessenger; <<
100 <<
101 delete fReflectorOpticalSurface; <<
102 } <<
103 88
104 //....oooOO0OOooo........oooOO0OOooo........oo 89 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
105 90
106 G4VPhysicalVolume* UltraDetectorConstruction:: 91 G4VPhysicalVolume* UltraDetectorConstruction::Construct()
107 { 92 {
>> 93 ConstructTableMaterials();
>> 94
>> 95
>> 96
108 // The experimental Hall 97 // The experimental Hall
109 // --------------------- 98 // ---------------------
110 99
111 auto World_x = 1.*m; << 100 G4double World_x = 1.*m;
112 auto World_y = 1.*m; << 101 G4double World_y = 1.*m;
113 auto World_z = 2*m; << 102 G4double World_z = 2*m;
114 103
115 auto World_box = new G4Box("World",World_x,W << 104 G4Box * World_box = new G4Box("World",World_x,World_y,World_z);
116 105
117 // Get Air pointer from static funcion - (G4 106 // Get Air pointer from static funcion - (G4Material::GetMaterial)
118 auto Air = G4Material::GetMaterial("Air"); <<
119 auto World_log = new G4LogicalVolume(World_b <<
120 107
121 fWorld_phys = new G4PVPlacement(0,G4ThreeV << 108 G4String name;
>> 109 G4Material *Air = G4Material::GetMaterial(name = "Air");
>> 110 G4LogicalVolume *World_log ;
>> 111 World_log = new G4LogicalVolume(World_box,Air,"World",0,0,0);
122 112
123 auto UniverseVisAtt = new G4VisAttributes(G << 113 G4VPhysicalVolume *World_phys ;
>> 114 World_phys = new G4PVPlacement(0,G4ThreeVector(),"World",World_log,0,false,0);
>> 115
>> 116 G4VisAttributes* UniverseVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
124 UniverseVisAtt->SetVisibility(true); 117 UniverseVisAtt->SetVisibility(true);
125 UniverseVisAtt->SetForceWireframe(true); 118 UniverseVisAtt->SetForceWireframe(true);
126 World_log->SetVisAttributes(UniverseVisAtt) 119 World_log->SetVisAttributes(UniverseVisAtt);
127 World_log->SetVisAttributes (G4VisAttribute << 120 World_log->SetVisAttributes (G4VisAttributes::Invisible);
128 121
129 122
130 123
131 G4cout << "\n \n \n \n \n \n \n \n \n \n \n 124 G4cout << "\n \n \n \n \n \n \n \n \n \n \n \n \n " << G4endl ;
132 125
133 G4cout << "################################# 126 G4cout << "######################################################" << G4endl ;
134 G4cout << "# 127 G4cout << "# #" << G4endl ;
135 G4cout << "# 128 G4cout << "# #" << G4endl ;
136 G4cout << "# UltraDetectorConstruct 129 G4cout << "# UltraDetectorConstruction: #" << G4endl ;
137 G4cout << "# << 130 G4cout << "# #" << G4endl ;
138 G4cout << "# << 131 G4cout << "# #" << G4endl ;
139 132
140 ConstructUVscope(); << 133 G4VPhysicalVolume* chosenVolume;
>> 134 chosenVolume = ConstructUVscope(World_phys);
141 135
142 136
143 G4cout << "# 137 G4cout << "# #" << G4endl ;
144 G4cout << "# 138 G4cout << "# #" << G4endl ;
145 G4cout << "################################# 139 G4cout << "######################################################" << G4endl ;
146 140
147 fIsReflectorConstructed = false; <<
148 141
149 return fWorld_phys; << 142 #ifdef ULTRA_MIRROR_USE
150 } <<
151 143
152 //....oooOO0OOooo........oooOO0OOooo........oo << 144 G4cout << "Using mirror reflecting surface " << G4endl ;
153 145
154 void UltraDetectorConstruction::ConstructSDand << 146 G4VPhysicalVolume* Mirror ;
155 { << 147 Mirror = ConstructMirror(World_phys);
156 auto PMTSD = new UltraPMTSD("PMTSD"); << 148
157 G4SDManager::GetSDMpointer()->AddNewDetector << 149 #elif ULTRA_GROUND_USE
158 SetSensitiveDetector(logicalPMT,PMTSD); << 150
>> 151 G4cout << "Using ground reflecting surface " << G4endl ;
>> 152
>> 153 G4VPhysicalVolume* Ground ;
>> 154 Ground = ConstructGround(World_phys);
>> 155
>> 156 #else
>> 157
>> 158 G4cout << "No reflecting surface used" << G4endl ;
>> 159
>> 160 #endif
>> 161
>> 162 return World_phys;
159 } 163 }
160 164
161 //....oooOO0OOooo........oooOO0OOooo........oo 165 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
162 166
163 void UltraDetectorConstruction::ConstructTable 167 void UltraDetectorConstruction::ConstructTableMaterials()
164 { 168 {
165 G4double a, z, density; 169 G4double a, z, density;
>> 170 G4String name, symbol;
>> 171 G4int nel;
>> 172
166 173
167 // ------------- Elements ------------- 174 // ------------- Elements -------------
168 a = 1.01*g/mole; 175 a = 1.01*g/mole;
169 auto elH = new G4Element("Hydrogen", "H", z << 176 G4Element* elH = new G4Element(name="Hydrogen", symbol="H", z=1., a);
170 177
171 a = 12.01*g/mole; 178 a = 12.01*g/mole;
172 auto elC = new G4Element("Carbon", "C", z=6 << 179 G4Element* elC = new G4Element(name="Carbon", symbol="C", z=6., a);
173 180
174 a = 14.01*g/mole; 181 a = 14.01*g/mole;
175 auto elN = new G4Element("Nitrogen", "N", z << 182 G4Element* elN = new G4Element(name="Nitrogen", symbol="N", z=7., a);
176 183
177 a = 16.00*g/mole; 184 a = 16.00*g/mole;
178 auto elO = new G4Element("Oxygen", "O", z= << 185 G4Element* elO = new G4Element(name="Oxygen", symbol="O", z=8., a);
179 186
180 a = 28.09*g/mole; 187 a = 28.09*g/mole;
181 auto elSi = new G4Element("Silicon", "Si", z << 188 G4Element* elSi = new G4Element(name="Silicon", symbol="Si", z=14., a);
182 189
183 190
184 // ------------- Materials ------------- 191 // ------------- Materials -------------
185 192
186 193
187 // Air 194 // Air
188 // --- 195 // ---
189 density = 1.29e-03*g/cm3; 196 density = 1.29e-03*g/cm3;
190 auto Air = new G4Material("Air", density, 2) << 197 G4Material* Air = new G4Material(name="Air", density, nel=2);
191 Air->AddElement(elN, .7); 198 Air->AddElement(elN, .7);
192 Air->AddElement(elO, .3); 199 Air->AddElement(elO, .3);
193 200
194 201
195 // Aluminum << 202 // Aluminum
196 // --------- 203 // ---------
197 a = 26.98*g/mole; 204 a = 26.98*g/mole;
198 density = 2.7*g/cm3; 205 density = 2.7*g/cm3;
199 new G4Material("Aluminum", z=13., a, density << 206 G4Material* Al ;
>> 207 Al = new G4Material(name="Aluminum", z=13., a, density);
200 208
201 209
202 // Quartz 210 // Quartz
203 // ------- 211 // -------
204 // density = 2.200*g/cm3; // fused quartz << 212 // density = 2.200*g/cm3; // fused quartz
205 density = 2.64*g/cm3; // crystalline quartz << 213 density = 2.64*g/cm3; // crystalline quartz (c.f. PDG)
206 auto Quartz = new G4Material("Quartz",densit << 214 G4Material *Quartz = new G4Material(name="Quartz",density, nel=2);
207 Quartz->AddElement(elSi, 1) ; 215 Quartz->AddElement(elSi, 1) ;
208 Quartz->AddElement(elO , 2) ; 216 Quartz->AddElement(elO , 2) ;
209 217
210 218
211 // PMMA C5H8O2 ( Acrylic ) 219 // PMMA C5H8O2 ( Acrylic )
212 // ------------- 220 // -------------
213 density = 1.19*g/cm3; 221 density = 1.19*g/cm3;
214 auto Acrylic = new G4Material("Acrylic", de << 222 G4Material* Acrylic = new G4Material(name="Acrylic", density, nel=3);
215 Acrylic->AddElement(elC, 5); 223 Acrylic->AddElement(elC, 5);
216 Acrylic->AddElement(elH, 8); 224 Acrylic->AddElement(elH, 8);
217 Acrylic->AddElement(elO, 2); 225 Acrylic->AddElement(elO, 2);
218 226
219 227
220 ///////////////////////////////////////////// 228 /////////////////////////////////////////////
221 // Construct Material Properties Tables 229 // Construct Material Properties Tables
222 ///////////////////////////////////////////// 230 /////////////////////////////////////////////
223 231
>> 232 const G4int NUMENTRIES = 2;
>> 233
224 // Energy bins 234 // Energy bins
225 std::vector<G4double> X_RINDEX = {h_Planck*c << 235 G4double X_RINDEX[NUMENTRIES] = {h_Planck*c_light/lambda_max, h_Planck*c_light/lambda_min} ;
226 236
227 237
228 // Air 238 // Air
229 std::vector<G4double> RINDEX_AIR{1.00, 1.00} << 239 G4double RINDEX_AIR[NUMENTRIES] = {1.00, 1.00} ;
230 // Air refractive index at 20 oC and 1 atm (fr << 240
231 for(auto&& i : RINDEX_AIR){ << 241 // Air refractive index at 20 oC and 1 atm (from PDG)
232 i = i + 2.73*std::pow(10.0,-4) ; << 242 for(G4int j=0 ; j<NUMENTRIES ; j++){
233 } << 243 RINDEX_AIR[j] = RINDEX_AIR[j] + 2.73*std::pow(10.0,-4) ;
>> 244 }
234 245
235 auto MPT_Air = new G4MaterialPropertiesTable << 246 G4MaterialPropertiesTable *MPT_Air = new G4MaterialPropertiesTable();
236 MPT_Air->AddProperty("RINDEX", X_RINDEX, RIN << 247 MPT_Air->AddProperty("RINDEX", X_RINDEX, RINDEX_AIR, NUMENTRIES);
237 Air->SetMaterialPropertiesTable(MPT_Air); 248 Air->SetMaterialPropertiesTable(MPT_Air);
238 249
239 ////////////////////////////////////////////// 250 //////////////////////////////////////////////////////////////////////////////////////
240 // Photomultiplier (PMT) window << 251 // Photomultiplier (PMT) window
241 // The refractive index is for lime glass; << 252 // The refractive index is for lime glass;
242 // wavelength dependence is not included and v 253 // wavelength dependence is not included and value at 400nm is used.
243 ////////////////////////////////////////////// 254 //////////////////////////////////////////////////////////////////////////////////////
244 255
245 // Refractive index << 256 // Refractive index
246 257
247 std::vector<G4double> X_RINDEX_QUARTZ{h_Plan << 258 const G4int N_RINDEX_QUARTZ = 2 ;
248 std::vector<G4double> RINDEX_QUARTZ{1.54, 1. << 259 G4double X_RINDEX_QUARTZ[N_RINDEX_QUARTZ] = {h_Planck*c_light/lambda_max, h_Planck*c_light/lambda_min} ;
>> 260 G4double RINDEX_QUARTZ[N_RINDEX_QUARTZ] = {1.54, 1.54};
249 261
250 auto MPT_PMT = new G4MaterialPropertiesTable << 262 G4MaterialPropertiesTable *MPT_PMT = new G4MaterialPropertiesTable();
251 MPT_PMT->AddProperty("RINDEX", X_RINDEX_QUAR << 263 MPT_PMT->AddProperty("RINDEX", X_RINDEX_QUARTZ, RINDEX_QUARTZ, N_RINDEX_QUARTZ);
252 264
253 Quartz->SetMaterialPropertiesTable(MPT_PMT); 265 Quartz->SetMaterialPropertiesTable(MPT_PMT);
254 266
255 267
256 ////////////////////////////////////////////// 268 //////////////////////////////////////////////////////////////////
257 // ACRYLIC Optical properties 269 // ACRYLIC Optical properties
258 ////////////////////////////////////////////// 270 //////////////////////////////////////////////////////////////////
259 271
260 // Refractive index << 272 // Refractive index
261 273
262 const auto NENTRIES = 11 ; << 274 const G4int NENTRIES = 11 ;
>> 275 G4double LAMBDA_ACRYLIC[NENTRIES] ;
263 276
264 std::vector<G4double> RINDEX_ACRYLIC; <<
265 std::vector<G4double> ENERGY_ACRYLIC; <<
266 277
267 // Parameterization for refractive index of Hi << 278 G4double RINDEX_ACRYLIC[NENTRIES] ;
>> 279 G4double ENERGY_ACRYLIC[NENTRIES] ;
268 280
269 G4double bParam[4] = {1760.7010,-1.3687,2.43 << 281 // Parameterization for refractive index of High Grade PMMA
270 auto lambda = 0.; <<
271 282
272 for(auto i=0;i<NENTRIES; ++i){ << 283 G4double bParam[4] = {1760.7010,-1.3687,2.4388e-3,-1.5178e-6} ;
>> 284
>> 285 for(G4int i=0;i<NENTRIES; i++){
>> 286
>> 287 LAMBDA_ACRYLIC[i] = lambda_min + i*(lambda_max-lambda_min)/float(NENTRIES-1) ;
>> 288 RINDEX_ACRYLIC[i] = 0.0 ;
273 289
274 // want energies in increasing order << 290 for (G4int jj=0 ; jj<4 ; jj++)
275 lambda = lambda_min + (NENTRIES-1-i) * (la <<
276 RINDEX_ACRYLIC.push_back(0.0); <<
277 <<
278 for (auto jj=0 ; jj<4 ; jj++) <<
279 { 291 {
280 RINDEX_ACRYLIC[i] += (bParam[jj]/1000.0 << 292 RINDEX_ACRYLIC[i] += (bParam[jj]/1000.0)*std::pow(LAMBDA_ACRYLIC[i]/nm,jj) ;
281 } 293 }
282 294
283 ENERGY_ACRYLIC.push_back(h_Planck*c_light/ << 295 ENERGY_ACRYLIC[i] = h_Planck*c_light/LAMBDA_ACRYLIC[i] ; // Convert from wavelength to energy ;
284 // G4cout << ENERGY_ACRYLIC[i]/eV << " " << l << 296 // G4cout << ENERGY_ACRYLIC[i]/eV << " " << LAMBDA_ACRYLIC[i]/nm << " " << RINDEX_ACRYLIC[i] << G4endl ;
>> 297
285 } 298 }
286 299
287 auto MPT_Acrylic = new G4MaterialPropertiesT << 300 G4MaterialPropertiesTable *MPT_Acrylic = new G4MaterialPropertiesTable();
288 MPT_Acrylic->AddProperty("RINDEX", ENERGY_AC << 301 MPT_Acrylic->AddProperty("RINDEX", ENERGY_ACRYLIC, RINDEX_ACRYLIC, NENTRIES);
>> 302
289 303
290 // Absorption 304 // Absorption
291 std::vector<G4double> LAMBDAABS << 305 const G4int NENT = 25 ;
>> 306 G4double LAMBDAABS[NENT] =
292 { 307 {
293 100.0, 308 100.0,
294 246.528671, 260.605103, 263.853516, 266.01 << 309 246.528671, 260.605103, 263.853516, 266.019104, 268.726105,
295 271.433136, 273.598724, 276.305725, 279.55 << 310 271.433136, 273.598724, 276.305725, 279.554138, 300.127380,
296 320.159241, 340.191101, 360.764343, 381.33 << 311 320.159241, 340.191101, 360.764343, 381.337585, 399.745239,
297 421.401276, 440.891724, 460.382172, 480.41 << 312 421.401276, 440.891724, 460.382172, 480.414001, 500.987274,
298 520.477722, 540.509583, 559.458618, 313 520.477722, 540.509583, 559.458618,
299 700.0 << 314 700.0
300 } ; 315 } ;
301 316
302 std::vector<G4double> T // Transmission (i << 317 G4double ABS[NENT] = // Transmission (in %) of 3mm thick PMMA
303 { << 318 {
304 0.0000000, 319 0.0000000,
305 0.0000000, 5.295952, 9.657321, 19.937695 << 320 0.0000000, 5.295952, 9.657321, 19.937695, 29.283491,
306 39.252335, 48.598133, 58.255451, 65.109039 321 39.252335, 48.598133, 58.255451, 65.109039, 79.439247,
307 85.669785, 89.719627, 91.277260, 91.588783 322 85.669785, 89.719627, 91.277260, 91.588783, 91.900307,
308 91.588783, 91.277260, 91.277260, 91.588783 323 91.588783, 91.277260, 91.277260, 91.588783, 91.588783,
309 91.900307, 91.900307, 91.588783, 324 91.900307, 91.900307, 91.588783,
310 91.5 325 91.5
311 } ; 326 } ;
312 327
313 328
314 auto abslengthMPV = new G4MaterialPropertyVe << 329 MPT_Acrylic->AddProperty("ABSLENGTH", new G4MaterialPropertyVector()) ;
315 for(size_t i=0;i<T.size(); ++i){ << 330 for(G4int i=0;i<NENT; i++){
316 auto energy = h_Planck*c_light/(LAMBDAA << 331 G4double energy = h_Planck*c_light/(LAMBDAABS[i]*nm) ;
317 auto abslength = 0.0; << 332 G4double abslength ;
318 333
319 if (T[i] <= 0.0) { << 334 if (ABS[i] <= 0.0) {
320 abslength = 1.0/kInfinity ; 335 abslength = 1.0/kInfinity ;
321 } 336 }
322 else { 337 else {
323 abslength = -3.0*mm/(G4Log(T[i]/100.0)) << 338 abslength = -3.0*mm/(std::log(ABS[i]/100.0)) ;
324 } 339 }
325 340
326 abslengthMPV->InsertValues(energy,abslengt << 341 MPT_Acrylic->AddEntry("ABSLENGTH", energy, abslength);
327 342
328 // MPT_Acrylic->AddEntry("ABSLENGTH", ener <<
329 } 343 }
330 344
331 MPT_Acrylic->AddProperty("ABSLENGTH", abslen <<
332 Acrylic->SetMaterialPropertiesTable(MPT_Acry 345 Acrylic->SetMaterialPropertiesTable(MPT_Acrylic);
>> 346
333 347
334 ////////////////////////////////////////////// 348 //////////////////////////////////////////////////////////////////
335 349
336 G4cout << *(G4Material::GetMaterialTable()) << 350 G4cout << *(G4Material::GetMaterialTable()) << G4endl ;
337 351
338 for (const auto& mat : *(G4Material::GetMate <<
339 if (mat->GetMaterialPropertiesTable()) { <<
340 G4cout << "Material properties for " << <<
341 mat->GetMaterialPropertiesTable()->DumpT <<
342 } <<
343 } <<
344 } 352 }
345 //....oooOO0OOooo........oooOO0OOooo........oo 353 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346 354
347 void UltraDetectorConstruction::ConstructRefle << 355 G4VPhysicalVolume* UltraDetectorConstruction::ConstructMirror(G4VPhysicalVolume *World_phys){
348 { << 356
349 const auto x = 40.0*cm; << 357 G4double Mirror_x = 40.0*cm;
350 const auto y = 40.0*cm; << 358 G4double Mirror_y = 40.0*cm;
351 const auto z = 1*cm; << 359 G4double Mirror_z = 1*cm;
352 360
353 auto box = new G4Box("Mirror",x,y,z); << 361 G4Box * boxMirror = new G4Box("Mirror",Mirror_x,Mirror_y,Mirror_z);
354 362
355 // Get Air pointer from static funcion - (G4 363 // Get Air pointer from static funcion - (G4Material::GetMaterial)
356 auto Al = G4Material::GetMaterial("Aluminum" <<
357 364
358 fReflectorLog = new G4LogicalVolume(box,Al," << 365 G4String name;
>> 366 G4Material *Al = G4Material::GetMaterial(name = "Aluminum");
>> 367 G4LogicalVolume *logMirror ;
>> 368 logMirror = new G4LogicalVolume(boxMirror,Al,"Mirror",0,0,0);
359 369
360 auto SurfacePosition = G4ThreeVector(0*m,0*m <<
361 370
362 // Rotate reflecting surface by 45. degrees << 371 G4ThreeVector SurfacePosition = G4ThreeVector(0*m,0*m,1.5*m) ;
363 372
364 auto Surfrot = new G4RotationMatrix(G4ThreeV << 373 // Rotate reflecting surface by 45. degrees around the OX axis.
365 374
366 new G4PVPlacement(Surfrot,SurfacePosition,"M << 375 G4RotationMatrix *Surfrot = new G4RotationMatrix(G4ThreeVector(1.0,0.0,0.0),-pi/4.);
367 376
368 auto SurfaceVisAtt = new G4VisAttributes(G4C << 377 G4VPhysicalVolume *physMirror ;
369 SurfaceVisAtt->SetVisibility(true); << 378 physMirror = new G4PVPlacement(Surfrot,SurfacePosition,"MirrorPV",logMirror,World_phys,false,0);
370 SurfaceVisAtt->SetForceWireframe(true); <<
371 fReflectorLog->SetVisAttributes(SurfaceVisAt <<
372 379
373 fReflectorOpticalSurface = new G4OpticalSurf << 380 G4VisAttributes* SurfaceVisAtt = new G4VisAttributes(G4Colour(0.0,0.0,1.0));
374 fReflectorOpticalSurface->SetModel(unified); << 381 SurfaceVisAtt->SetVisibility(true);
375 fReflectorOpticalSurface->SetType(dielectric << 382 SurfaceVisAtt->SetForceWireframe(true);
>> 383 logMirror->SetVisAttributes(SurfaceVisAtt);
376 384
377 std::vector<G4double> XX{h_Planck*c_light/la <<
378 std::vector<G4double> ICEREFLECTIVITY{ 0.95, <<
379 385
380 auto AirMirrorMPT = new G4MaterialProperties << 386 //////////////////////////////////////////////////////////////////////////////////////////
381 AirMirrorMPT->AddProperty("REFLECTIVITY", XX << 387 // Optical properties of the interface between the Air and Reflective Surface
382 fReflectorOpticalSurface->SetMaterialPropert << 388 // For Mirror, reflectivity is set at 95% and specular reflection is assumed.
383 389
384 new G4LogicalSkinSurface("ReflectorSurface", <<
385 390
386 #ifdef G4MULTITHREADED << 391 G4OpticalSurface *OpticalAirMirror = new G4OpticalSurface("AirMirrorSurface");
387 auto runManager = G4MTRunManager::GetMasterR << 392 OpticalAirMirror->SetModel(unified);
388 //runManager->SetNumberOfThreads(2); << 393 OpticalAirMirror->SetType(dielectric_dielectric);
389 #else << 394 OpticalAirMirror->SetFinish(polishedfrontpainted);
390 auto runManager = G4RunManager::GetRunManage << 395
391 #endif << 396 const G4int NUM = 2;
>> 397 G4double XX[NUM] = {h_Planck*c_light/lambda_max, h_Planck*c_light/lambda_min} ;
>> 398 G4double ICEREFLECTIVITY[NUM] = { 0.95, 0.95 };
>> 399
>> 400 G4MaterialPropertiesTable *AirMirrorMPT = new G4MaterialPropertiesTable();
>> 401 AirMirrorMPT->AddProperty("REFLECTIVITY", XX, ICEREFLECTIVITY,NUM);
>> 402 OpticalAirMirror->SetMaterialPropertiesTable(AirMirrorMPT);
392 403
393 runManager->GeometryHasBeenModified(); <<
394 404
395 fIsReflectorConstructed = true; << 405 G4LogicalBorderSurface *AirMirror ;
>> 406 AirMirror = new G4LogicalBorderSurface("Air/Mirror Surface",World_phys,physMirror,OpticalAirMirror);
>> 407
>> 408 return physMirror ;
>> 409
396 } 410 }
397 411
>> 412 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 413
>> 414 G4VPhysicalVolume* UltraDetectorConstruction::ConstructGround(G4VPhysicalVolume *World_phys){
>> 415
>> 416 G4double Ground_x = 40.0*cm;
>> 417 G4double Ground_y = 40.0*cm;
>> 418 G4double Ground_z = 1*cm;
>> 419
>> 420 G4Box * boxGround = new G4Box("Ground",Ground_x,Ground_y,Ground_z);
>> 421
>> 422 // Get Air pointer from static funcion - (G4Material::GetMaterial)
>> 423
>> 424 G4String name;
>> 425 G4Material *Al = G4Material::GetMaterial(name = "Aluminum");
>> 426 G4LogicalVolume *logGround ;
>> 427 logGround = new G4LogicalVolume(boxGround,Al,"Ground",0,0,0);
>> 428
>> 429
>> 430 G4ThreeVector SurfacePosition = G4ThreeVector(0*m,0*m,1.5*m) ;
>> 431
>> 432 // Rotate reflecting surface by 45. degrees around the OX axis.
>> 433
>> 434 G4RotationMatrix *Surfrot = new G4RotationMatrix(G4ThreeVector(1.0,0.0,0.0),-pi/4.);
>> 435
>> 436 G4VPhysicalVolume *physGround ;
>> 437 physGround = new G4PVPlacement(Surfrot,SurfacePosition,"GroundPV",logGround,World_phys,false,0);
>> 438
>> 439 G4VisAttributes* SurfaceVisAtt = new G4VisAttributes(G4Colour(0.0,0.0,1.0));
>> 440 SurfaceVisAtt->SetVisibility(true);
>> 441 SurfaceVisAtt->SetForceWireframe(true);
>> 442 logGround->SetVisAttributes(SurfaceVisAtt);
>> 443
>> 444
>> 445 //////////////////////////////////////////////////////////////////////////////////////////
>> 446 // Optical properties of the interface between the Air and Reflective Surface
>> 447 // For Ground, reflectivity is set to 95% and diffusive reflection is assumed.
>> 448
>> 449
>> 450 G4OpticalSurface *OpticalAirGround = new G4OpticalSurface("AirGroundSurface");
>> 451 OpticalAirGround->SetModel(unified);
>> 452 OpticalAirGround->SetType(dielectric_dielectric);
>> 453 OpticalAirGround->SetFinish(groundfrontpainted);
>> 454
>> 455 const G4int NUM = 2;
>> 456 G4double XX[NUM] = {h_Planck*c_light/lambda_max, h_Planck*c_light/lambda_min} ;
>> 457 G4double ICEREFLECTIVITY[NUM] = { 0.95, 0.95 };
>> 458
>> 459 G4MaterialPropertiesTable *AirGroundMPT = new G4MaterialPropertiesTable();
>> 460 AirGroundMPT->AddProperty("REFLECTIVITY", XX, ICEREFLECTIVITY,NUM);
>> 461 OpticalAirGround->SetMaterialPropertiesTable(AirGroundMPT);
>> 462
>> 463
>> 464 G4LogicalBorderSurface *AirGround ;
>> 465 AirGround = new G4LogicalBorderSurface("Air/Ground Surface",World_phys,physGround,OpticalAirGround);
>> 466
>> 467 return physGround ;
398 468
399 void UltraDetectorConstruction::SetReflectorOp <<
400 { <<
401 if (fReflectionType == "ground") { <<
402 G4cout << "Using ground reflecting surface <<
403 if (fReflectorOpticalSurface) <<
404 fReflectorOpticalSurface->SetFinish(grou <<
405 } <<
406 else { <<
407 G4cout << "Using mirror reflecting surface <<
408 if (fReflectorOpticalSurface) <<
409 fReflectorOpticalSurface->SetFinish(poli <<
410 } <<
411 } 469 }
412 470
413 471
>> 472
414 //....oooOO0OOooo........oooOO0OOooo........oo 473 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
415 474
416 void UltraDetectorConstruction::ConstructUVsco << 475 G4VPhysicalVolume* UltraDetectorConstruction::ConstructUVscope(G4VPhysicalVolume *World_phys){
417 { <<
418 476
419 // ------------- Volumes -------------- << 477 // ------------- Volumes --------------
420 478
421 //////////////////////////////////////////// << 479 ////////////////////////////////////////////////////////////////////////////////////////////////////////
422 480
423 G4cout << "# << 481 G4cout << "# #" << G4endl ;
424 G4cout << "# Building the Telescop << 482 G4cout << "# Building the Telescope ... #" << G4endl ;
425 G4cout << "# << 483 G4cout << "# #" << G4endl ;
426 484
427 //////////////////////////////////////////// << 485 /////////////////////////////////////////////////////////////
428 // UVscope housing is a cylinder made of 1 m << 486 // UVscope housing is a cylinder made of 1 mm thick aluminum
429 //////////////////////////////////////////// << 487 /////////////////////////////////////////////////////////////
430 488
431 auto UVscopeHeight = 1030.0*mm ; << 489 G4double UVscopeHeight = 1030.0*mm ;
432 auto UVscopeDiameter = 518.0*mm ; << 490 G4double UVscopeDiameter = 518.0*mm ;
433 auto UVscopeThickness = 1.0*mm ; << 491 G4double UVscopeThickness = 1.0*mm ;
434 auto UVscopeBaffle = 514.0*mm ; << 492 G4double UVscopeBaffle = 514.0*mm ;
435 493
436 auto UVscopeInnerRadius = UVscopeDiameter/2. << 494 G4double UVscopeInnerRadius = UVscopeDiameter/2.0-UVscopeThickness ;
437 auto UVscopeOuterRadius = UVscopeDiameter/2. << 495 G4double UVscopeOuterRadius = UVscopeDiameter/2.0 ;
438 496
439 auto UVscopePosition = G4ThreeVector(0.0*m,0 << 497 G4ThreeVector UVscopePosition = G4ThreeVector(0.0*m,0.0*m,-1.0*m) ;
440 auto Al = G4Material::GetMaterial("Aluminum" << 498 G4String name;
>> 499 G4Material* Al = G4Material::GetMaterial(name = "Aluminum");
441 500
442 auto solidUVscope = <<
443 new G4Tubs("UVscopeSolid",UVscopeInnerRadi <<
444 auto logicUVscope = <<
445 new G4LogicalVolume(solidUVscope,Al,"UVsco <<
446 auto physicalUVscope = <<
447 new G4PVPlacement(0,UVscopePosition,"UVSCo <<
448 501
>> 502 G4Tubs *solidUVscope =
>> 503 new G4Tubs("UVscopeSolid",UVscopeInnerRadius,UVscopeOuterRadius,UVscopeHeight/2.0,0.0,twopi) ;
>> 504 G4LogicalVolume *logicUVscope =
>> 505 new G4LogicalVolume(solidUVscope,Al,"UVscopeLV",0,0,0);
>> 506 G4VPhysicalVolume *physicalUVscope =
>> 507 new G4PVPlacement(0,UVscopePosition,"UVSCopePV",logicUVscope,World_phys,false,0);
449 508
450 ////////////////////////////////////// <<
451 // Back cover of the UVscope cylinder <<
452 ////////////////////////////////////// <<
453 509
454 auto solidUVscopeBack = << 510 //////////////////////////////////////
455 new G4Tubs("UVscopeBackSolid",0.0,UVscopeO << 511 // Back cover of the UVscope cylinder
>> 512 //////////////////////////////////////
456 513
457 auto logicUVscopeBack = << 514 G4Tubs *solidUVscopeBack =
458 new G4LogicalVolume(solidUVscopeBack,Al,"U << 515 new G4Tubs("UVscopeBackSolid",0.0,UVscopeOuterRadius,UVscopeThickness/2.0,0.0,twopi) ;
459 516
460 auto UVscopeBackPosition = << 517 G4LogicalVolume *logicUVscopeBack =
461 UVscopePosition+G4ThreeVector(0.0*mm,0.0*m << 518 new G4LogicalVolume(solidUVscopeBack,Al,"UVscopeBackLV",0,0,0);
462 auto physicalUVscopeBack = <<
463 new G4PVPlacement(0,UVscopeBackPosition,"U <<
464 519
465 //////////////////////////////////////////// << 520 G4ThreeVector UVscopeBackPosition ;
>> 521 UVscopeBackPosition = UVscopePosition+G4ThreeVector(0.0*mm,0.0*mm,-(UVscopeHeight/2.0+UVscopeThickness/2.0)) ;
>> 522 G4VPhysicalVolume *physicalUVscopeBack =
>> 523 new G4PVPlacement(0,UVscopeBackPosition,"UVscopeBack",logicUVscopeBack,World_phys,false,0);
466 524
467 G4cout << "# <<
468 G4cout << "# Building the Fresnel <<
469 G4cout << "# <<
470 525
471 auto LensDiameter = 457*mm ; // <<
472 auto LensNumOfGrooves = 13 ; <<
473 //auto LensNumOfGrooves = 129 ; <<
474 //auto LensNumOfGrooves = 1287 ; <<
475 526
476 auto LensBorderThickness = 2.8*mm ; << 527 ////////////////////////////////////////////////////////////////////////////////////////////////////////
477 auto LensFocalLength = 441.973*mm ; <<
478 auto LensMaterial = G4Material:: <<
479 auto LensPosition = UVscopePosit <<
480 528
>> 529 G4cout << "# #" << G4endl ;
>> 530 G4cout << "# Building the Fresnel lens ... #" << G4endl ;
>> 531 G4cout << "# #" << G4endl ;
481 532
482 FresnelLens = new UltraFresnelLens(LensDiame << 533 G4double LensDiameter = 457*mm ; // Size of the optical active area of the lens.
>> 534 G4int LensNumOfGrooves = 13 ;
>> 535 //G4int LensNumOfGrooves = 129 ;
>> 536 //G4int LensNumOfGrooves = 1287 ;
483 537
>> 538 G4double LensBorderThickness = 2.8*mm ; // Thickness of the border area.
>> 539 G4double LensFocalLength = 441.973*mm ; // This parameter depends on the lens geometry, etc !!
>> 540 G4Material *LensMaterial = G4Material::GetMaterial(name = "Acrylic") ;
>> 541 G4ThreeVector LensPosition = UVscopePosition+G4ThreeVector(0.0*mm,0.0*mm,UVscopeHeight/2.0-UVscopeBaffle) ;
484 542
485 /////////////////////////////////// <<
486 // Lens supporting ring (aluminum) <<
487 /////////////////////////////////// <<
488 543
489 auto solidLensFrame = new G4Tubs("LensFrame" << 544 UltraFresnelLens *FresnelLens = new UltraFresnelLens(LensDiameter,LensNumOfGrooves,LensMaterial,World_phys,LensPosition) ;
490 auto logicLensFrame = new G4LogicalVolume(so <<
491 545
492 auto LensFramePosition = LensPosition+G4Thre <<
493 546
494 auto physicalLensFrame = << 547 ///////////////////////////////////
495 new G4PVPlacement(0,LensFramePosition,"Len << 548 // Lens supporting ring (aluminum)
>> 549 ///////////////////////////////////
496 550
497 //////////////////////////////////////////// << 551 G4Tubs *solidLensFrame = new G4Tubs("LensFrame",LensDiameter/2.0,UVscopeInnerRadius,LensBorderThickness/2.0,0.0,twopi) ;
>> 552 G4LogicalVolume *logicLensFrame = new G4LogicalVolume(solidLensFrame,Al,"LensFrameLV",0,0,0);
498 553
>> 554 G4ThreeVector LensFramePosition ;
>> 555 LensFramePosition = LensPosition+G4ThreeVector(0.0*mm,0.0*mm,-((FresnelLens->GetThickness())/2.0+solidLensFrame->GetDz())) ;
499 556
500 G4cout << "# << 557 G4VPhysicalVolume *physicalLensFrame =
501 G4cout << "# Building the photomulti << 558 new G4PVPlacement(0,LensFramePosition,"LensFramePV",logicLensFrame,World_phys,false,0);
502 G4cout << "# <<
503 559
>> 560 ////////////////////////////////////////////////////////////////////////////////////////////////////////
504 561
505 // Photomultiplier window is a spherical sec <<
506 562
507 auto PMT_thick = 1.0*mm ; // Thickness o << 563 G4cout << "# #" << G4endl ;
508 auto PMT_curv = 65.5*mm ; // Radius of c << 564 G4cout << "# Building the photomultiplier ... #" << G4endl ;
509 auto StartTheta = (180.0-31.2)*pi/180. ; << 565 G4cout << "# #" << G4endl ;
510 auto EndTheta = 31.2*pi/180. ; <<
511 566
512 auto solidPMT = <<
513 new G4Sphere("PMT_solid",PMT_curv-PMT_thic <<
514 567
515 auto Quartz = G4Material::GetMaterial("Quart << 568 // Photomultiplier window is a spherical section made of quartz
516 logicalPMT = new G4LogicalVolume(solidPMT,Qu <<
517 569
>> 570 G4double PMT_thick = 1.0*mm ; // Thickness of PMT window
>> 571 G4double PMT_curv = 65.5*mm ; // Radius of curvature of PMT window
>> 572 G4double StartTheta = (180.0-31.2)*pi/180. ;
>> 573 G4double EndTheta = 31.2*pi/180. ;
518 574
519 // Place PMT is at Lens Focus << 575 G4Sphere *solidPMT ;
>> 576 solidPMT = new G4Sphere("PMT_solid",PMT_curv-PMT_thick,PMT_curv,0.0,twopi,StartTheta,EndTheta);
520 577
521 auto PMTpos = LensPosition + G4ThreeVector(0 << 578 G4Material* Quartz = G4Material::GetMaterial(name = "Quartz");
>> 579 G4LogicalVolume * logicalPMT ;
>> 580 logicalPMT = new G4LogicalVolume(solidPMT,Quartz,"PMT_log",0,0,0);
522 581
523 // Rotate PMT window through the axis OX by <<
524 582
525 auto PMTrot = new G4RotationMatrix(G4ThreeVe << 583 // Place PMT is at Lens Focus
526 new G4PVPlacement(PMTrot,PMTpos,"PMT1",logic <<
527 584
>> 585 G4ThreeVector PMTpos = LensPosition + G4ThreeVector(0.0*cm,0.0*cm,-(LensFocalLength+PMT_curv)) ;
528 586
529 auto PMTVisAtt = new G4VisAttributes(true, << 587 // Rotate PMT window through the axis OX by an angle = 180. degrees
530 logicalPMT->SetVisAttributes(PMTVisAtt); <<
531 588
532 //////////////////////////////////////////// << 589 G4RotationMatrix *PMTrot = new G4RotationMatrix(G4ThreeVector(1.0,0.0,0.0),pi);
533 // Optical properties of the interface bet << 590 G4VPhysicalVolume *physPMT ;
534 // UVscope cylinder (5% reflectivity) << 591 physPMT = new G4PVPlacement(PMTrot,PMTpos,"PMT1",logicalPMT,World_phys,false,0);
535 592
>> 593 if(!PMTSD)
>> 594 {
>> 595 PMTSD = new UltraPMTSD("PMTSD");
>> 596 SDmanager->AddNewDetector( PMTSD );
>> 597 }
536 598
537 G4cout << "# Defining interface's optical << 599 if (logicalPMT){logicalPMT->SetSensitiveDetector(PMTSD);}
538 G4cout << "# <<
539 600
>> 601 G4VisAttributes* PMTVisAtt = new G4VisAttributes(true,G4Colour(0.0,0.0,1.0)) ;
>> 602 logicalPMT->SetVisAttributes(PMTVisAtt);
540 603
541 auto OpticalAirPaint = new G4OpticalSurface( << 604 //////////////////////////////////////////////////////////////////////////////////////////
542 OpticalAirPaint->SetModel(unified); << 605 // Optical properties of the interface between the Air and the walls of the
543 OpticalAirPaint->SetType(dielectric_dielectr << 606 // UVscope cylinder (5% reflectivity)
544 OpticalAirPaint->SetFinish(groundfrontpainte <<
545 607
546 std::vector<G4double> XX = {h_Planck*c_light <<
547 std::vector<G4double> BLACKPAINTREFLECTIVITY <<
548 //std::vector<G4double> WHITEPAINTREFLECTIVI <<
549 608
550 auto AirPaintMPT = new G4MaterialPropertiesT << 609 G4cout << "# Defining interface's optical properties ... #" << G4endl ;
551 AirPaintMPT->AddProperty("REFLECTIVITY", XX, << 610 G4cout << "# #" << G4endl ;
552 OpticalAirPaint->SetMaterialPropertiesTable( <<
553 611
554 //OpticalAirPaint->DumpInfo(); <<
555 612
556 new G4LogicalBorderSurface("Air/UVscope Cyli << 613 G4OpticalSurface *OpticalAirPaint = new G4OpticalSurface("AirPaintSurface");
>> 614 OpticalAirPaint->SetModel(unified);
>> 615 OpticalAirPaint->SetType(dielectric_dielectric);
>> 616 OpticalAirPaint->SetFinish(groundfrontpainted);
557 617
558 new G4LogicalBorderSurface("Air/LensFrame Su << 618 const G4int NUM = 2;
>> 619 G4double XX[NUM] = {h_Planck*c_light/lambda_max, h_Planck*c_light/lambda_min} ;
>> 620 G4double BLACKPAINTREFLECTIVITY[NUM] = { 0.05, 0.05 };
>> 621 //G4double WHITEPAINTREFLECTIVITY[NUM] = { 0.99, 0.99 };
559 622
560 new G4LogicalBorderSurface("Air/UVscope Back << 623 G4MaterialPropertiesTable *AirPaintMPT = new G4MaterialPropertiesTable();
>> 624 AirPaintMPT->AddProperty("REFLECTIVITY", XX, BLACKPAINTREFLECTIVITY,NUM);
>> 625 OpticalAirPaint->SetMaterialPropertiesTable(AirPaintMPT);
561 626
>> 627 //OpticalAirPaint->DumpInfo();
562 628
563 //////////////////////////////////////////// << 629 G4LogicalBorderSurface *AirCylinder ;
>> 630 AirCylinder = new G4LogicalBorderSurface("Air/UVscope Cylinder Surface",World_phys,physicalUVscope,OpticalAirPaint);
564 631
565 auto LensVisAtt = new G4VisAttributes(G4Col << 632 G4LogicalBorderSurface *AirLensFrame ;
566 LensVisAtt ->SetVisibility(true); << 633 AirLensFrame = new G4LogicalBorderSurface("Air/LensFrame Surface",World_phys,physicalLensFrame,OpticalAirPaint);
567 634
>> 635 G4LogicalBorderSurface *AirBackCover ;
>> 636 AirBackCover = new G4LogicalBorderSurface("Air/UVscope Back Cover Surface",World_phys,physicalUVscopeBack,OpticalAirPaint);
568 637
569 if (FresnelLens){ <<
570 FresnelLens->GetPhysicalVolume()->GetLogic <<
571 } <<
572 638
573 auto UVscopeVisAtt = new G4VisAttributes(G4 << 639 /////////////////////////////////////////////////////////////////////////////////////
574 UVscopeVisAtt ->SetVisibility(true); <<
575 640
576 physicalUVscope ->GetLogicalVolume()->Se <<
577 physicalUVscopeBack ->GetLogicalVolume()->Se <<
578 physicalLensFrame ->GetLogicalVolume()->Se <<
579 641
580 //////////////////////////////////////////// << 642 G4VisAttributes* LensVisAtt = new G4VisAttributes(G4Colour(1.0,0.0,0.0)) ; // Red
>> 643 LensVisAtt ->SetVisibility(true);
581 644
582 G4cout << "# <<
583 G4cout << "# UVscope is built <<
584 G4cout << "# <<
585 645
586 } << 646 if (FresnelLens){
>> 647 FresnelLens->GetPhysicalVolume()->GetLogicalVolume()->SetVisAttributes(LensVisAtt);
>> 648 }
587 649
>> 650 G4VisAttributes* UVscopeVisAtt = new G4VisAttributes(G4Colour(0.5,0.5,0.5)) ; // Gray
>> 651 UVscopeVisAtt ->SetVisibility(true);
588 652
589 void UltraDetectorConstruction::SetReflectionT << 653 physicalUVscope ->GetLogicalVolume()->SetVisAttributes(UVscopeVisAtt);
590 { << 654 physicalUVscopeBack ->GetLogicalVolume()->SetVisAttributes(UVscopeVisAtt);
591 #ifdef G4MULTITHREADED << 655 physicalLensFrame ->GetLogicalVolume()->SetVisAttributes(UVscopeVisAtt);
592 auto runManager = G4MTRunManager::GetMasterR <<
593 //runManager->SetNumberOfThreads(2); <<
594 #else <<
595 auto runManager = G4RunManager::GetRunManage <<
596 #endif <<
597 656
598 fReflectionType = rtype; << 657 /////////////////////////////////////////////////////////////////////////////////////
599 658
600 if (fReflectionType == "none") { << 659 G4cout << "# #" << G4endl ;
601 if (fIsReflectorConstructed) { << 660 G4cout << "# UVscope is built ! ... #" << G4endl ;
602 // Cleanup old geometry to delete reflec << 661 G4cout << "# #" << G4endl ;
603 runManager->ReinitializeGeometry(true); << 662
604 } << 663 return physicalUVscope;
605 } <<
606 else { <<
607 if (!fIsReflectorConstructed) { <<
608 ConstructReflector(); <<
609 } <<
610 SetReflectorOpticalProperties(); <<
611 } <<
612 } 664 }
>> 665
>> 666
>> 667 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 668
>> 669
>> 670
613 671