ATLAS Offline Software
EMECAccordionConstruction.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2024-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // EMECAccordionConstruction
6 // Construct internal structure of the EMEC Inner and Outer Wheels
7 
8 // Revision history:
9 // 24-Jan-2024 Evgueni Tcherniaev: Initial version
10 
11 #include <cmath>
12 #include <iostream>
13 
14 #include "LArGeoEndcap/EMECAccordionConstruction.h"
15 
16 #include "GeoModelKernel/GeoElement.h"
17 #include "GeoModelKernel/GeoMaterial.h"
18 #include "GeoModelKernel/GeoFullPhysVol.h"
19 #include "GeoModelKernel/GeoPhysVol.h"
20 #include "GeoModelKernel/GeoVPhysVol.h"
21 #include "GeoModelKernel/GeoLogVol.h"
22 #include "GeoModelKernel/GeoBox.h"
23 #include "GeoModelKernel/GeoCons.h"
24 #include "GeoModelKernel/GeoPcon.h"
25 #include "GeoModelKernel/GeoGenericTrap.h"
26 #include "GeoModelKernel/GeoNameTag.h"
27 #include "GeoModelKernel/GeoTransform.h"
28 #include "GeoModelKernel/GeoIdentifierTag.h"
29 #include "GeoModelKernel/GeoPublisher.h"
30 #include "GeoModelKernel/Units.h"
31 
32 #include "RDBAccessSvc/IRDBAccessSvc.h"
33 #include "RDBAccessSvc/IRDBRecord.h"
34 #include "RDBAccessSvc/IRDBRecordset.h"
35 
36 #include "StoreGate/StoreGateSvc.h"
37 #include "GaudiKernel/MsgStream.h"
38 #include "GaudiKernel/ISvcLocator.h"
39 #include "GaudiKernel/PhysicalConstants.h"
40 #include "GaudiKernel/StatusCode.h"
41 #include "GeoModelUtilities/DecodeVersionKey.h"
42 #include "GeoModelInterfaces/IGeoModelSvc.h"
43 #include "GeoModelInterfaces/IGeoDbTagSvc.h"
44 
45 #define SI GeoModelKernelUnits
46 
48 //
49 // Set parameters for accordion structure construction
50 //
51 void LArGeo::EMECAccordionConstruction::setWheelParameters()
52 {
53  ISvcLocator *svcLocator = Gaudi::svcLocator();
54  StoreGateSvc *detStore;
55  if(svcLocator->service("DetectorStore", detStore, false)==StatusCode::FAILURE) {
56  throw std::runtime_error("Error in EndcapCryostatConstruction, cannot access DetectorStore");
57  }
58 
59  // Get GeoModelSvc and RDBAccessSvc
60 
61  IRDBAccessSvc* rdbAccess(nullptr);
62  IGeoModelSvc* geoModelSvc(nullptr);
63  StatusCode sc = svcLocator->service("RDBAccessSvc",rdbAccess);
64  if(sc != StatusCode::SUCCESS){
65  throw std::runtime_error("EMECConstruction: cannot locate RDBAccessSvc!");
66  }
67 
68  sc = svcLocator->service ("GeoModelSvc",geoModelSvc);
69  if(sc != StatusCode::SUCCESS){
70  throw std::runtime_error("EMECAccordionConstruction: cannot locate GeoModelSvc!");
71  }
72 
73  DecodeVersionKey larVersionKey(geoModelSvc, "LAr");
74  IRDBRecordset_ptr DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", larVersionKey.tag(), larVersionKey.node());
75  if(DB_EmecGeometry->size() == 0){
76  DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", "EmecGeometry-00");
77  std::cout<< "Building NEW EMEC ACCORDION STRUCTURE" <<std::endl;
78  }
79 
80  IRDBRecordset_ptr emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", larVersionKey.tag(), larVersionKey.node());
81  if(emecWheelParameters->size() == 0){
82  emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", "EmecWheelParameters-00");
83  std::cout<< "EmecWheelParameters" <<std::endl;
84  }
85 
86 
87  IRDBRecordset_ptr emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", larVersionKey.tag(), larVersionKey.node());
88  if(emecMagicNumbers->size() == 0){
89  emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", "EmecMagicNumbers-00");
90  std::cout<< "EmecMagicNumbers" <<std::endl;
91  }
92 
93  IRDBRecordset_ptr coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", larVersionKey.tag(), larVersionKey.node());
94  if(coldContraction->size() == 0){
95  coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", "ColdContraction-00");
96  std::cout<< "ColdContraction" <<std::endl;
97  }
98 
99  IRDBRecordset_ptr emecFan = rdbAccess->getRecordsetPtr("EmecFan", larVersionKey.tag(), larVersionKey.node());
100  if(emecFan->size() == 0){
101  emecFan = rdbAccess->getRecordsetPtr("EmecFan", "EmecFan-00");
102  std::cout<< "EmecFan" <<std::endl;
103  }
104 
105 
106  // Inner wheel accordion wave parameters
107  m_innerNoAbsorbes = (*emecWheelParameters)[0]->getInt("NABS"); // 256
108  m_innerNoElectrodes = (*emecWheelParameters)[0]->getInt("NABS"); // 256
109  m_innerNoWaves = (*emecWheelParameters)[0]->getInt("NACC"); // 6
110 
111  m_innerLipWidth = (*emecMagicNumbers)[0]->getDouble("STRAIGHTSTARTSECTION") * SI::mm; // 2 mm
112  m_innerWaveZoneWidth = (*emecMagicNumbers)[0]->getDouble("ACTIVELENGTH") * SI::mm; // 510 mm
113  m_innerWheelWidth = m_innerWaveZoneWidth + 2*m_innerLipWidth; // 514 mm
114  m_innerWaveWidth = m_innerWaveZoneWidth/m_innerNoWaves; // 510/6 = 85 mm
115  m_innerHalfWaveWidth = m_innerWaveWidth/2;
116  m_innerQuaterWaveWidth = m_innerWaveWidth/4;
117 
118  // Check values
119  if (m_innerNoAbsorbes != 256) {
120  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string( m_innerNoAbsorbes) + ") for Inner Wheel, expected 256!");
121  }
122  if (m_innerNoWaves != 6) {
123  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string( m_innerNoAbsorbes ) + ") for Inner Wheel, expected 6!");
124  }
125  if (m_innerLipWidth != 2 * SI::mm) {
126  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber lips. (STRAIGHTSTARTSECTION = " + std::to_string( m_innerNoAbsorbes/SI::mm) + "), expected 2 mm!" );
127  }
128  if (m_innerWaveZoneWidth != 510 * SI::mm) {
129  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber active zone. (ACTIVELENGTH = " + std::to_string(m_innerWaveZoneWidth/SI::mm) + "), expected 510 mm!");
130  }
131 
132  // Outer wheel accordion wave parameters
133  m_outerNoAbsorbes = (*emecWheelParameters)[1]->getInt("NABS"); // 768
134  m_outerNoElectrodes = (*emecWheelParameters)[1]->getInt("NABS"); // 768
135  m_outerNoWaves = (*emecWheelParameters)[1]->getInt("NACC"); // 9
136 
137  m_outerLipWidth = m_innerLipWidth; // 2 mm
138  m_outerWaveZoneWidth = m_innerWaveZoneWidth; // 510 mm
139  m_outerWheelWidth = m_outerWaveZoneWidth + 2*m_outerLipWidth; // 514 mm
140  m_outerWaveWidth = m_outerWaveZoneWidth/m_outerNoWaves; // 510/9 = 56.67 mm
141  m_outerHalfWaveWidth = m_outerWaveWidth/2;
142  m_outerQuaterWaveWidth = m_outerWaveWidth/4;
143 
144  // Check values
145  if (m_outerNoAbsorbes != 768) {
146  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string (m_outerNoAbsorbes) + ") for Outer Wheel, expected 768!");
147  }
148  if (m_outerNoWaves != 9) {
149  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string(m_outerNoAbsorbes) + ") for Outer Wheel, expected 9!" );
150  }
151 
152  // Inner wheel thiknesses
153  m_innerLeadThickness = (*emecFan)[0]->getDouble("LEADTHICKNESSINNER") * SI::mm; // 2.2 mm
154  m_innerSteelThickness = (*emecFan)[0]->getDouble("STEELTHICKNESS") * SI::mm; // 0.2 mm
155  m_innerGlueThickness = (*emecFan)[0]->getDouble("GLUETHICKNESS") * SI::mm; // 0.1 mm (TRD: 0.15 mm)
156  m_innerElectrodeThickness = (*emecFan)[0]->getDouble("ELECTRODETOTALTHICKNESS") * SI::mm; // 0.275 mm
157 
158  // Outer wheel thiknesses
159  m_outerLeadThickness = (*emecFan)[0]->getDouble("LEADTHICKNESSOUTER") * SI::mm; // 1.69 mm (TRD: 1.7 mm)
160  m_outerSteelThickness = m_innerSteelThickness;
161  m_outerGlueThickness = m_innerGlueThickness;
162  m_outerElectrodeThickness = m_innerElectrodeThickness;
163 
164  // E.T. notes:
165  // 1. In LArCustomShapeExtensionSolid.cxx the contraction factor was equal to 0.991, here 0.997
166  // 2. There is a discrepancy between specified thickness of glue (0.1 mm) and its value in TDR (0.15 mm)
167  // 3. There is a discrepancy between specified thickness of lead in the outer wheel (1.69 mm) and its value in TDR (1.7 mm)
168  // 4. Application of the contraction factor to the thicknesses (?) is under question
169  // 5. Materials are specified at room temperature (?) instead of LAr temperature
170  // 6. Iron (?) is used instead of Steel in absorbers
171  //
172  // for more information see:
173  // https://indico.cern.ch/event/1236615/contributions/5313135/attachments/2610372/4509836/2023.03.13-EMEC_discrepancies.pdf
174 
175  // Contraction factor
176  m_kContraction = (*coldContraction)[0]->getDouble("ABSORBERCONTRACTION"); // 0.997, in LArCustomShapeExtensionSolid.cxx was 0.991
177 
178  // Applying contraction factor to thicknesses (?)
179  m_innerLeadThickness *= m_kContraction;
180  m_innerSteelThickness *= m_kContraction;
181  m_innerGlueThickness *= m_kContraction;
182  m_innerAbsorberThickness = m_innerLeadThickness + 2*m_innerSteelThickness + 2*m_innerGlueThickness;
183 
184  m_outerLeadThickness *= m_kContraction;
185  m_outerSteelThickness *= m_kContraction;
186  m_outerGlueThickness *= m_kContraction;
187  m_outerAbsorberThickness = m_outerLeadThickness + 2*m_outerSteelThickness + 2*m_outerGlueThickness;
188 
189  // 1./eleInvContraction = 0.99639
190  double eleInvContraction = (*coldContraction)[0]->getDouble("ELECTRODEINVCONTRACTION"); // 1.0036256
191  m_innerElectrodeThickness /= eleInvContraction;
192  m_outerElectrodeThickness /= eleInvContraction;
193 }
194 
196 //
197 // Set pointer to Inner Wheeel envelope
198 //
199 void LArGeo::EMECAccordionConstruction::setInnerWheel(GeoFullPhysVol* innerWheel)
200 {
201  m_innerWheel = innerWheel;
202  const GeoShape* shape = innerWheel->getLogVol()->getShape();
203  if (shape->type() != "Pcon") {
204  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setInnerWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
205  }
206  const GeoPcon* pcon = (GeoPcon *)shape;
207  auto nplanes = pcon->getNPlanes();
208  if (nplanes != 2) {
209  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheel: wrong number of Z planes '" + std::to_string(nplanes) + "', expected '2'!");
210  }
211  for (unsigned int i = 0; i < nplanes; ++i)
212  {
213  m_zWheelInner[i] = pcon->getZPlane(i);
214  m_rMinInner[i] = pcon->getRMinPlane(i);
215  m_rMaxInner[i] = pcon->getRMaxPlane(i);
216  }
217  // Set Inner Wheel base name
218  m_nameInnerWheel = innerWheel->getLogVol()->getName();
219 }
220 
222 //
223 // Set pointer to Outer Wheeel envelope
224 //
225 void LArGeo::EMECAccordionConstruction::setOuterWheel(GeoFullPhysVol* outerWheel)
226 {
227  m_outerWheel = outerWheel;
228  const GeoShape* shape = outerWheel->getLogVol()->getShape();
229  if (shape->type() != "Pcon") {
230  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
231 
232  }
233  const GeoPcon* pcon = (GeoPcon *)shape;
234  auto nplanes = pcon->getNPlanes();
235  if (nplanes != 3) {
236  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setOuterWheel: wrong number of Z planes" + std::to_string(nplanes) + "', expected '3'!" );
237  }
238  for (unsigned int i = 0; i < nplanes; ++i)
239  {
240  m_zWheelOuter[i] = pcon->getZPlane(i);
241  m_rMinOuter[i] = pcon->getRMinPlane(i);
242  m_rMaxOuter[i] = pcon->getRMaxPlane(i);
243  }
244  // Set Outer Wheel base name
245  m_nameOuterWheel = outerWheel->getLogVol()->getName();
246 }
247 
249 //
250 // Set Inner wheel slices: (lip)(quater_wave)(11 half_waves)(quater_wave)(lip)
251 //
252 void LArGeo::EMECAccordionConstruction::setInnerWheelSlices()
253 {
254  if (!m_innerWheel)
255  {
256  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheelSlices: Inner Wheel volume is not set!" );
257  }
258  // Compute slices
259  m_innerWheelRminIncrement = (m_rMinInner[1] - m_rMinInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
260  m_innerWheelRmaxIncrement = (m_rMaxInner[1] - m_rMaxInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
261  m_innerWheelZmin = m_zWheelInner[0];
262  m_innerWheelZmax = m_zWheelInner[1];
263 
264  m_innerWheelZ[0] = m_innerWheelZmin;
265  m_innerWheelZ[1] = m_innerWheelZ[0] + m_innerLipWidth;
266  m_innerWheelZ[2] = m_innerWheelZ[1] + m_innerQuaterWaveWidth;
267  for (int i = 3; i < s_innerNoBlades - 1; ++i)
268  {
269  m_innerWheelZ[i] = m_innerWheelZ[i - 1] + m_innerHalfWaveWidth;
270  }
271  m_innerWheelZ[s_innerNoBlades] = m_innerWheelZmax;
272  m_innerWheelZ[s_innerNoBlades - 1] = m_innerWheelZ[s_innerNoBlades] - m_innerLipWidth;
273  for (int i = 0; i < s_innerNoBlades + 1; ++i)
274  {
275  m_innerWheelRmin[i] = m_rMinInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRminIncrement;
276  m_innerWheelRmax[i] = m_rMaxInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRmaxIncrement;
277  }
278 }
279 
281 //
282 // Set Outer wheel slices (lip)(quater_wave)(15_half_waves)(quater_wave)(lip)
283 //
284 void LArGeo::EMECAccordionConstruction::setOuterWheelSlices()
285 {
286  if (!m_outerWheel)
287  {
288  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheelSlices: Outer Wheel volume is not set!");
289  }
290  // Compute slices
291  m_outerWheelRminIncrement[0] = (m_rMinOuter[1] - m_rMinOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
292  m_outerWheelRminIncrement[1] = (m_rMinOuter[2] - m_rMinOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
293  m_outerWheelRmaxIncrement[0] = (m_rMaxOuter[1] - m_rMaxOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
294  m_outerWheelRmaxIncrement[1] = (m_rMaxOuter[2] - m_rMaxOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
295  m_outerWheelZmin = m_zWheelOuter[0];
296  m_outerWheelZmax = m_zWheelOuter[2];
297 
298  m_outerWheelZ[0] = m_outerWheelZmin;
299  m_outerWheelZ[1] = m_outerWheelZ[0] + m_outerLipWidth;
300  m_outerWheelZ[2] = m_outerWheelZ[1] + m_outerQuaterWaveWidth;
301  for (int i = 3; i < s_outerNoBlades - 1; ++i)
302  {
303  m_outerWheelZ[i] = m_outerWheelZ[i - 1] + m_outerHalfWaveWidth;
304  }
305  m_outerWheelZ[s_outerNoBlades] = m_outerWheelZmax;
306  m_outerWheelZ[s_outerNoBlades - 1] = m_outerWheelZ[s_outerNoBlades] - m_outerLipWidth;
307  for (int i = 0; i < s_outerNoBlades + 1; ++i)
308  {
309  m_outerWheelRmin[i] = m_rMinOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRminIncrement[0];
310  m_outerWheelRmax[i] = m_rMaxOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRmaxIncrement[0];
311  if (m_outerWheelRmax[i] > m_rMaxOuter[2]) m_outerWheelRmax[i] = m_rMaxOuter[2]; // 2034 mm starting from i = 3
312  }
313 }
314 
316 //
317 // Set material
318 //
319 void
320 LArGeo::EMECAccordionConstruction::setMaterial(const std::string& name,
321  const GeoMaterial* material)
322 {
323  if (name == "LiquidArgon") m_materialLiquidArgon = material;
324  else if (name == "Kapton") m_materialKapton = material;
325  else if (name == "Lead" ) m_materialLead = material;
326  else if (name == "Steel" ) m_materialSteel = material;
327  else if (name == "Glue" ) m_materialGlue = material;
328  else
329  {
330  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setMaterial: unexpected material name '" + name + "'!");
331  }
332 }
333 
335 //
336 // Get Inner absorber data from technical information
337 //
338 void
339 LArGeo::EMECAccordionConstruction::getInnerAbsorberData(double& wmin, double& wmax,
340  double& llip1, double& ylip1,
341  double& llip2, double& ylip2) const
342 {
343  // Points taken from technical drawing
344  GeoTwoVector A[14+1] = {}; // A[0] is not used
345  A[1] = GeoTwoVector( 1.700, 1019.908) * SI::mm;
346  A[2] = GeoTwoVector( 36.595, 1022.643) * SI::mm;
347  A[3] = GeoTwoVector(110.351, 1024.416) * SI::mm;
348  A[4] = GeoTwoVector(184.545, 1020.841) * SI::mm;
349  A[5] = GeoTwoVector(258.785, 1011.865) * SI::mm;
350  A[6] = GeoTwoVector(332.678, 997.463) * SI::mm;
351  A[7] = GeoTwoVector(405.824, 977.640) * SI::mm;
352  A[8] = GeoTwoVector(477.824, 952.430) * SI::mm;
353  A[9] = GeoTwoVector(548.280, 921.895) * SI::mm;
354  A[10] = GeoTwoVector(616.797, 886.130) * SI::mm;
355  A[11] = GeoTwoVector(682.985, 845.257) * SI::mm;
356  A[12] = GeoTwoVector(746.463, 799.426) * SI::mm;
357  A[13] = GeoTwoVector(806.859, 748.819) * SI::mm;
358  A[14] = GeoTwoVector(835.788, 723.065) * SI::mm;
359 
360  GeoTwoVector B[14+1] = {}; // B[0] is not used
361  B[1] = GeoTwoVector( 1.132, 710.702) * SI::mm;
362  B[2] = GeoTwoVector( 25.476, 711.930) * SI::mm;
363  B[3] = GeoTwoVector( 76.670, 711.749) * SI::mm;
364  B[4] = GeoTwoVector(127.967, 707.873) * SI::mm;
365  B[5] = GeoTwoVector(179.099, 700.288) * SI::mm;
366  B[6] = GeoTwoVector(229.797, 688.988) * SI::mm;
367  B[7] = GeoTwoVector(279.791, 674.025) * SI::mm;
368  B[8] = GeoTwoVector(328.814, 655.414) * SI::mm;
369  B[9] = GeoTwoVector(376.600, 633.227) * SI::mm;
370  B[10] = GeoTwoVector(422.886, 607.546) * SI::mm;
371  B[11] = GeoTwoVector(467.418, 578.473) * SI::mm;
372  B[12] = GeoTwoVector(509.946, 546.127) * SI::mm;
373  B[13] = GeoTwoVector(550.228, 510.649) * SI::mm;
374  B[14] = GeoTwoVector(568.629, 492.593) * SI::mm;
375 
376  GeoTwoVector C[4+1] = {}; // C[0] is not used
377  C[1] = GeoTwoVector( -1.754, 978.281) * SI::mm;
378  C[2] = GeoTwoVector( 1.668, 978.279) * SI::mm;
379  C[3] = GeoTwoVector(803.643, 696.378) * SI::mm;
380  C[4] = GeoTwoVector(805.917, 693.745) * SI::mm;
381 
382  GeoTwoVector D[4+1] = {}; // D[0] is not used
383  D[1] = GeoTwoVector( -1.894, 786.281) * SI::mm;
384  D[2] = GeoTwoVector( 1.186, 786.279) * SI::mm;
385  D[3] = GeoTwoVector(610.986, 529.319) * SI::mm;
386  D[4] = GeoTwoVector(613.041, 526.940) * SI::mm;
387 
388  // Compute angle between rays
389  int k1 = 2, k2 = 13; // take rays 2 and 13
390  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
391  double ang = std::acos(cosa)/(k2 - k1);
392 
393  // Compute bottom and top width of the accordion blade
394  double rmin = B[1].norm();
395  double rmax = A[14].norm();
396  wmin = 2.*rmin*std::sin(ang/2.);
397  wmax = 2.*rmax*std::sin(ang/2.);
398 
399  // Compute length and position of the first lip
400  llip1 = (C[2] - D[2]).norm();
401  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
402 
403  // Compute length and position of the last lip
404  llip2 = (C[3] - D[3]).norm();
405  ylip2 = (D[3] - B[14]).norm() + llip2/2.;
406 }
407 
409 //
410 // Get Outer absorber data from technical information
411 //
412 void
413 LArGeo::EMECAccordionConstruction::getOuterAbsorberData(double& wmin, double& wmax,
414  double& llip1, double& ylip1,
415  double& llip2, double& ylip2) const
416 {
417  // Points taken from technical drawing
418  GeoTwoVector A[20+1] = {}; // A[0] is not used
419  A[1] = GeoTwoVector( 1.773, 3438.343) * SI::mm;
420  A[2] = GeoTwoVector( 26.515, 3445.688) * SI::mm;
421  A[3] = GeoTwoVector( 79.893, 3460.218) * SI::mm;
422  A[4] = GeoTwoVector(133.523, 3468.701) * SI::mm;
423  A[5] = GeoTwoVector(186.888, 3466.236) * SI::mm;
424  A[6] = GeoTwoVector(240.209, 3462.949) * SI::mm;
425  A[7] = GeoTwoVector(293.473, 3458.842) * SI::mm;
426  A[8] = GeoTwoVector(346.668, 3453.916) * SI::mm;
427  A[9] = GeoTwoVector(399.780, 3448.172) * SI::mm;
428  A[10] = GeoTwoVector(452.798, 3441.612) * SI::mm;
429  A[11] = GeoTwoVector(505.708, 3434.236) * SI::mm;
430  A[12] = GeoTwoVector(558.499, 3426.047) * SI::mm;
431  A[13] = GeoTwoVector(611.157, 3417.046) * SI::mm;
432  A[14] = GeoTwoVector(663.670, 3407.236) * SI::mm;
433  A[15] = GeoTwoVector(716.027, 3396.619) * SI::mm;
434  A[16] = GeoTwoVector(768.214, 3385.198) * SI::mm;
435  A[17] = GeoTwoVector(820.219, 3372.975) * SI::mm;
436  A[18] = GeoTwoVector(872.029, 3359.953) * SI::mm;
437  A[19] = GeoTwoVector(923.633, 3346.135) * SI::mm;
438  A[20] = GeoTwoVector(947.625, 3339.413) * SI::mm;
439 
440  GeoTwoVector B[20+1] = {}; // B[0] is not used
441  B[1] = GeoTwoVector( 0.810, 2046.995) * SI::mm;
442  B[2] = GeoTwoVector( 15.769, 2049.165) * SI::mm;
443  B[3] = GeoTwoVector( 47.410, 2053.375) * SI::mm;
444  B[4] = GeoTwoVector( 79.185, 2057.095) * SI::mm;
445  B[5] = GeoTwoVector(111.086, 2060.323) * SI::mm;
446  B[6] = GeoTwoVector(143.105, 2063.055) * SI::mm;
447  B[7] = GeoTwoVector(175.234, 2065.288) * SI::mm;
448  B[8] = GeoTwoVector(207.466, 2067.020) * SI::mm;
449  B[9] = GeoTwoVector(239.792, 2068.248) * SI::mm;
450  B[10] = GeoTwoVector(272.205, 2068.969) * SI::mm;
451  B[11] = GeoTwoVector(304.697, 2069.181) * SI::mm;
452  B[12] = GeoTwoVector(337.260, 2068.883) * SI::mm;
453  B[13] = GeoTwoVector(369.885, 2068.071) * SI::mm;
454  B[14] = GeoTwoVector(402.566, 2066.744) * SI::mm;
455  B[15] = GeoTwoVector(435.293, 2064.899) * SI::mm;
456  B[16] = GeoTwoVector(468.058, 2062.536) * SI::mm;
457  B[17] = GeoTwoVector(500.853, 2059.653) * SI::mm;
458  B[18] = GeoTwoVector(533.670, 2056.247) * SI::mm;
459  B[19] = GeoTwoVector(566.501, 2052.318) * SI::mm;
460  B[20] = GeoTwoVector(582.048, 2050.271) * SI::mm;
461 
462  GeoTwoVector C[4+1] = {}; // C[0] is not used
463  C[1] = GeoTwoVector( -1.682, 3416.858) * SI::mm;
464  C[2] = GeoTwoVector( 1.756, 3416.858) * SI::mm;
465  C[3] = GeoTwoVector(932.782, 3287.070) * SI::mm;
466  C[3] = GeoTwoVector(936.090, 3286.130) * SI::mm;
467 
468  GeoTwoVector D[4+1] = {}; // D[0] is not used
469  D[1] = GeoTwoVector( -1.975, 2088.411) * SI::mm;
470  D[2] = GeoTwoVector( 0.839, 2088.410) * SI::mm;
471  D[3] = GeoTwoVector(593.526, 2090.743) * SI::mm;
472  D[4] = GeoTwoVector(596.271, 2089.963) * SI::mm;
473 
474  // Compute angle between rays
475  int k1 = 4, k2 = 19; // take rays 4 and 19
476  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
477  double ang = std::acos(cosa)/(k2 - k1);
478 
479  // Compute bottom and top width of the accordion blade
480  double rmin = B[1].norm();
481  double rmax = A[19].norm(); // A[19] has slightly bigger radius than A[20]
482  wmin = 2.*rmin*std::sin(ang/2.);
483  wmax = 2.*rmax*std::sin(ang/2.);
484 
485  // Compute length and position of the first lip
486  llip1 = (C[2] - D[2]).norm();
487  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
488 
489  // Compute length and position of the last lip
490  llip2 = (C[3] - D[3]).norm();
491  ylip2 = (D[3] - B[20]).norm() + llip2/2.;
492 }
493 
495 //
496 // Compute uncut Blade corners
497 //
498 void
499 LArGeo::EMECAccordionConstruction::getBladeCorners(double wmin, double wmax, double thickness,
500  double rmin, double rmax, double zdel,
501  GeoThreeVector corners[8]) const
502 {
503  double z = zdel/2.;
504 
505  double xmin = std::sqrt(wmin*wmin - zdel*zdel)/2.;
506  double dxmin = (thickness/2.)*(wmin/zdel);
507  double ymin = rmin;
508 
509  double xmax = std::sqrt(wmax*wmax - zdel*zdel)/2.;
510  double dxmax = (thickness/2.)*(wmax/zdel);
511  double xtmp = (xmax + dxmax);
512  double ymax = std::sqrt(rmax*rmax - xtmp*xtmp);
513 
514  corners[0] = GeoThreeVector(-xmin + dxmin, ymin, -z);
515  corners[1] = GeoThreeVector(-xmin - dxmin, ymin, -z);
516  corners[2] = GeoThreeVector(-xmax - dxmax, ymax, -z);
517  corners[3] = GeoThreeVector(-xmax + dxmax, ymax, -z);
518 
519  corners[4] = GeoThreeVector(+xmin + dxmin, ymin, +z);
520  corners[5] = GeoThreeVector(+xmin - dxmin, ymin, +z);
521  corners[6] = GeoThreeVector(+xmax - dxmax, ymax, +z);
522  corners[7] = GeoThreeVector(+xmax + dxmax, ymax, +z);
523 }
524 
526 //
527 // Compute cut plane for bottom of Blade
528 //
529 LArGeo::EMECAccordionConstruction::CutPlane
530 LArGeo::EMECAccordionConstruction::getBottomCutPlane(double zmin, double rmin,
531  double zmax, double rmax) const
532 {
533  GeoThreeVector pmin(0, rmin, zmin);
534  GeoThreeVector pmax(0, rmax, zmax);
535  GeoThreeVector v = (pmax - pmin).normalized();
536 
537  LArGeo::EMECAccordionConstruction::CutPlane plane;
538  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
539  plane.m_d = -plane.m_n.dot(pmin);
540  return plane;
541 }
542 
544 //
545 // Compute cut plane for top of Blade
546 //
547 LArGeo::EMECAccordionConstruction::CutPlane
548 LArGeo::EMECAccordionConstruction::getTopCutPlane(double zmin, double rmin,
549  double zmax, double rmax,
550  const GeoThreeVector corners[8]) const
551 {
552  GeoThreeVector pbot(std::min(corners[0].x(), corners[1].x()), corners[0].y(), 0);
553  GeoThreeVector ptop(std::min(corners[2].x(), corners[3].x()), corners[3].y(), 0);
554 
555  GeoThreeVector v = (ptop - pbot).normalized();
556  double d = v.x()*pbot.y() - v.y()*pbot.x();
557  double r = ptop.norm();
558  double l = std::sqrt(r*r - d*d);
559  double wmin = std::sqrt(rmin*rmin - d*d);
560  double wmax = std::sqrt(rmax*rmax - d*d);
561  double ymin = ptop.y() - v.y()*(l - wmin);
562  double ymax = ptop.y() - v.y()*(l - wmax);
563 
564  GeoThreeVector pmin(0, ymin, zmin);
565  GeoThreeVector pmax(0, ymax, zmax);
566  v = (pmax - pmin).normalized();
567 
568  LArGeo::EMECAccordionConstruction::CutPlane plane;
569  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
570  plane.m_d = -plane.m_n.dot(pmin);
571  return plane;
572 }
573 
575 //
576 // Find intersection of line segment with plane
577 //
578 GeoThreeVector
579 LArGeo::EMECAccordionConstruction::IntersectionPoint(const GeoThreeVector& p1,
580  const GeoThreeVector& p2,
581  const LArGeo::EMECAccordionConstruction::CutPlane& plane) const
582 {
583  double d1 = plane.m_n.dot(p1) + plane.m_d;
584  double d2 = plane.m_n.dot(p2) + plane.m_d;
585  return (d2*p1 - d1*p2)/(d2 - d1);
586 }
587 
589 //
590 // Cut Blade and construct solid
591 // icase = 1 - first quater-wave, negative inclination
592 // icase = 2 - half-wave, positive inclination
593 // icase = 3 - half-wave, negative inclination
594 // icase = 4 - last quater-wave, positive inclination
595 //
596 GeoShape*
597 LArGeo::EMECAccordionConstruction::constructBlade(int icase,
598  const GeoThreeVector corners[8], double xscale,
599  double pz1, double pr1min, double pr1max,
600  double pz2, double pr2min, double pr2max) const
601 {
602  double z1 = pz1, r1min = pr1min, r1max = pr1max;
603  double z2 = pz2, r2min = pr2min, r2max = pr2max;
604  if (icase == 1) // First quater-wave blade
605  {
606  z1 -= (z2 - z1);
607  r1min -= (r2min - r1min);
608  r1max -= (r2max - r1max);
609  }
610  if (icase == 4) // Last quater-wave blade
611  {
612  z2 += (z2 - z1);
613  r2min += (r2min - r1min);
614  r2max += (r2max - r1max);
615  }
616 
617  // Prepare Blade for cutting
618  std::vector<GeoThreeVector> v3(8);
619  double kx = (icase == 2) ? 1 : -1; // set inclination
620 
621  // Move Blade to required position
622  for (int i = 0; i < 8; ++i)
623  {
624  v3[i] = GeoThreeVector(kx*corners[i].x(), corners[i].y(), corners[i].z() + (z1 + z2)/2.);
625  }
626 
627  // Change order vertices in case of negative inclination
628  if (kx < 0)
629  {
630  std::swap(v3[0],v3[1]);
631  std::swap(v3[2],v3[3]);
632  std::swap(v3[4],v3[5]);
633  std::swap(v3[6],v3[7]);
634  }
635 
636  // Cut Blade by bottom plane
637  LArGeo::EMECAccordionConstruction::CutPlane botPlane = getBottomCutPlane(z1, r1min, z2, r2min);
638  v3[0] = IntersectionPoint(v3[0], v3[3], botPlane);
639  v3[1] = IntersectionPoint(v3[1], v3[2], botPlane);
640  v3[4] = IntersectionPoint(v3[4], v3[7], botPlane);
641  v3[5] = IntersectionPoint(v3[5], v3[6], botPlane);
642 
643  // Cut Blade by top plane
644  LArGeo::EMECAccordionConstruction::CutPlane topPlane = getTopCutPlane(z1, r1max, z2, r2max, corners);
645  v3[3] = IntersectionPoint(v3[0], v3[3], topPlane);
646  v3[2] = IntersectionPoint(v3[1], v3[2], topPlane);
647  v3[7] = IntersectionPoint(v3[4], v3[7], topPlane);
648  v3[6] = IntersectionPoint(v3[5], v3[6], topPlane);
649 
650  if (icase == 1) // First quater-wave blade
651  {
652  v3[0] = (v3[0] + v3[4])/2.;
653  v3[1] = (v3[1] + v3[5])/2.;
654  v3[2] = (v3[2] + v3[6])/2.;
655  v3[3] = (v3[3] + v3[7])/2.;
656  }
657 
658  if (icase == 4) // Last quater-wave blade
659  {
660  v3[4] = (v3[0] + v3[4])/2.;
661  v3[5] = (v3[1] + v3[5])/2.;
662  v3[6] = (v3[2] + v3[6])/2.;
663  v3[7] = (v3[3] + v3[7])/2.;
664  }
665 
666  // Construct GenericTrap solid
667  //
668  // +--------Z
669  // |
670  // | 3 +----------+ 7
671  // | 0 +------|---+ 4 |
672  // X | 2 +----------+ 6
673  // 1 +----------+ 5
674  //
675  std::vector<GeoTwoVector> v2(8);
676  for (int i = 0; i < 8; i += 2)
677  {
678  double xmid = (v3[i + 1].x() + v3[i].x())/2.;
679  double xdel = (v3[i + 1].x() - v3[i].x())*xscale/2.;
680  v2[i + 0] = GeoTwoVector(xmid - xdel, v3[i + 0].y());
681  v2[i + 1] = GeoTwoVector(xmid + xdel, v3[i + 1].y());
682  }
683  return new GeoGenericTrap((pz2 - pz1)/2., v2);
684 }
685 
687 //
688 // Construct Slices in Inner Wheel, set offsets
689 //
690 void LArGeo::EMECAccordionConstruction::constructInnerSlices()
691 {
692  std::string name;
693  GeoShape* solid;
694  for (int islice = 0; islice < s_innerNoBlades; ++islice)
695  {
696  name = m_nameInnerWheel + m_nameSlice + m_nameSuffix[islice];
697  double dz = 0.5*(m_innerWheelZ[islice+1] - m_innerWheelZ[islice]);
698  solid = new GeoCons(m_innerWheelRmin[islice], m_innerWheelRmin[islice+1],
699  m_innerWheelRmax[islice], m_innerWheelRmax[islice+1],
700  dz, 0.*SI::deg, 360.*SI::deg);
701  m_innerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
702  m_innerSliceOffset[islice] = GeoThreeVector(0., 0., m_innerWheelZ[islice] + dz);
703  }
704 }
705 
707 //
708 // Construct Slices in Outer Wheel, set offsets
709 //
710 void LArGeo::EMECAccordionConstruction::constructOuterSlices()
711 {
712  std::string name;
713  GeoShape* solid;
714  for (int islice = 0; islice < s_outerNoBlades; ++islice)
715  {
716  name = m_nameOuterWheel + m_nameSlice + m_nameSuffix[islice];
717  double dz = 0.5*(m_outerWheelZ[islice+1] - m_outerWheelZ[islice]);
718  solid = new GeoCons(m_outerWheelRmin[islice], m_outerWheelRmin[islice+1],
719  m_outerWheelRmax[islice], m_outerWheelRmax[islice+1],
720  dz, 0.*SI::deg, 360.*SI::deg);
721  m_outerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
722  m_outerSliceOffset[islice] = GeoThreeVector(0., 0., m_outerWheelZ[islice] + dz);
723  }
724 }
725 
727 //
728 // Construct Lips of Absorbers and Electrodes for Inner Wheel
729 // Set offsets
730 //
731 void
732 LArGeo::EMECAccordionConstruction::constructInnerLips(double innerLipLength1,
733  double innerLipPosition1,
734  double innerLipLength2,
735  double innerLipPosition2)
736 {
737  double dx, dy, dz, xoffset, yoffset, zoffset;
738  std::string name;
739  GeoShape* solid;
740 
741  // Contruct logical volumes for 1st lip
742  int iblade = 0;
743  dx = 0.5*m_innerAbsorberThickness;
744  dy = 0.5*innerLipLength1;
745  dz = 0.5*m_innerLipWidth;
746  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
747  solid = new GeoBox(dx, dy, dz);
748  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
749 
750  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
751  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
752  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
753 
754  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
755  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
756  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
757 
758  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
759  dx = 0.5*m_innerElectrodeThickness;
760  solid = new GeoBox(dx, dy, dz);
761  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
762 
763  // Set offsets
764  xoffset = 0.;
765  yoffset = m_innerWheelRmin[1] + innerLipPosition1;
766  zoffset = m_innerWheelZmin + dz;
767  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
768  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
769 
770  // Contruct logical volumes for 2nd lip
771  iblade = s_innerNoBlades - 1;
772  dx = 0.5*m_innerAbsorberThickness;
773  dy = 0.5*innerLipLength2;
774  dz = 0.5*m_innerLipWidth;
775  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
776  solid = new GeoBox(dx, dy, dz);
777  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
778 
779  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
780  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
781  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
782 
783  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
784  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
785  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
786 
787  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
788  dx = 0.5*m_innerElectrodeThickness;
789  solid = new GeoBox(dx, dy, dz);
790  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
791 
792  // Set offsets
793  xoffset = 0.;
794  yoffset = m_innerWheelRmin[s_innerNoBlades - 1] + innerLipPosition2;
795  zoffset = m_innerWheelZmax - dz;
796  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
797  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
798 }
799 
801 //
802 // Construct Lips of Absorbers and Electrodes for Outer Wheel
803 // Set offsets
804 //
805 void LArGeo::EMECAccordionConstruction::constructOuterLips(double outerLipLength1,
806  double outerLipPosition1,
807  double outerLipLength2,
808  double outerLipPosition2)
809 {
810  double dx, dy, dz, xoffset, yoffset, zoffset;
811  std::string name;
812  GeoShape* solid;
813 
814  // Contruct logical volumes for 1st lip
815  int iblade = 0;
816  dx = 0.5*m_outerAbsorberThickness;
817  dy = 0.5*outerLipLength1;
818  dz = 0.5*m_outerLipWidth;
819  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
820  solid = new GeoBox(dx, dy, dz);
821  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
822 
823  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
824  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
825  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
826 
827  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
828  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
829  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
830 
831  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
832  dx = 0.5*m_outerElectrodeThickness;
833  solid = new GeoBox(dx, dy, dz);
834  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
835 
836  // Set offsets
837  xoffset = 0.;
838  yoffset = m_outerWheelRmin[1] + outerLipPosition1;
839  zoffset = m_outerWheelZmin + dz;
840  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
841  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
842 
843  // Contruct logical volumes for 2nd lip
844  iblade = s_outerNoBlades - 1;
845  dx = 0.5*m_outerAbsorberThickness;
846  dy = 0.5*outerLipLength2;
847  dz = 0.5*m_outerLipWidth;
848  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
849  solid = new GeoBox(dx, dy, dz);
850  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
851 
852  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
853  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
854  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
855 
856  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
857  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
858  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
859 
860  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
861  dx = 0.5*m_outerElectrodeThickness;
862  solid = new GeoBox(dx, dy, dz);
863  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
864 
865  // Set offsets
866  xoffset = 0.;
867  yoffset = m_outerWheelRmin[s_outerNoBlades -1] + outerLipPosition2;
868  zoffset = m_outerWheelZmax - dz;
869  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
870  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
871 }
872 
874 //
875 // Construct Blades of Absorbers and Electrodes for Inner Wheel
876 // Set offsets
877 //
878 void
879 LArGeo::EMECAccordionConstruction::constructInnerBlades(const GeoThreeVector innerCorners[8],
880  const GeoThreeVector innerElectrodeCorners[8])
881 {
882  std::string name;
883  GeoShape* solid;
884 
885  for (int iblade = 1; iblade < s_innerNoBlades - 1; ++iblade)
886  {
887  int icase = (iblade%2 == 0) ? 2 : 3; // positive/negative inclination
888  if (iblade == 1) icase = 1; // first quater-wave
889  if (iblade == s_innerNoBlades - 2) icase = 4; // last quater-wave
890 
891  double z1 = m_innerWheelZ[iblade];
892  double r1min = m_innerWheelRmin[iblade];
893  double r1max = m_innerWheelRmax[iblade];
894  double z2 = m_innerWheelZ[iblade + 1];
895  double r2min = m_innerWheelRmin[iblade + 1];
896  double r2max = m_innerWheelRmax[iblade + 1];
897 
898  // Construct volumes for Absorber, Glue, Lead and Electrode
899  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
900  solid = constructBlade(icase, innerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
901  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
902 
903  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
904  solid = constructBlade(icase, innerCorners, m_innerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
905  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
906 
907  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
908  solid = constructBlade(icase, innerCorners, m_innerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
909  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
910 
911  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
912  solid = constructBlade(icase, innerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
913  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
914 
915  // Set offsets
916  m_innerAbsorberOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
917  m_innerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
918  }
919 }
920 
922 //
923 // Construct Blades of Absorbers and Electrodes for Outer Wheel
924 // Set offsets
925 //
926 void
927 LArGeo::EMECAccordionConstruction::constructOuterBlades(const GeoThreeVector outerCorners[8],
928  const GeoThreeVector outerElectrodeCorners[8])
929 {
930  std::string name;
931  GeoShape* solid;
932 
933  for (int iblade = 1; iblade < s_outerNoBlades - 1; ++iblade)
934  {
935  int icase = (iblade%2 == 0) ? 2 : 3; // positive/negative inclination
936  if (iblade == 1) icase = 1; // first quater-wave
937  if (iblade == s_outerNoBlades - 2) icase = 4; // last quater-wave
938 
939  double z1 = m_outerWheelZ[iblade];
940  double r1min = m_outerWheelRmin[iblade];
941  double r1max = m_outerWheelRmax[iblade];
942  double z2 = m_outerWheelZ[iblade + 1];
943  double r2min = m_outerWheelRmin[iblade + 1];
944  double r2max = m_outerWheelRmax[iblade + 1];
945 
946  // Construct volumes for Absorber, Glue, Lead and Electrode
947  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
948  solid = constructBlade(icase, outerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
949  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
950 
951  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
952  solid = constructBlade(icase, outerCorners, m_outerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
953  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
954 
955  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
956  solid = constructBlade(icase, outerCorners, m_outerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
957  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
958 
959  // Construct solid for Electrode
960  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
961  solid = constructBlade(icase, outerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
962  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
963 
964  // Set offsets
965  m_outerAbsorberOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
966  m_outerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
967  }
968 }
969 
971 //
972 // Place Glue and Lead into Inner Wheel Absorbers
973 //
974 void LArGeo::EMECAccordionConstruction::placeInnerGlueAndLead()
975 {
976  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
977  {
978  m_innerGlue[iblade]->add(m_innerLead[iblade]);
979  m_innerAbsorber[iblade]->add(m_innerGlue[iblade]);
980  }
981 }
982 
984 //
985 // Place Glue and Lead into Outer Wheel Absorbers
986 //
987 void LArGeo::EMECAccordionConstruction::placeOuterGlueAndLead()
988 {
989  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
990  {
991  m_outerGlue[iblade]->add(m_outerLead[iblade]);
992  m_outerAbsorber[iblade]->add(m_outerGlue[iblade]);
993  }
994 }
995 
997 //
998 // Place Slices in Inner Wheel, if needed
999 //
1000 void LArGeo::EMECAccordionConstruction::placeInnerSlices(bool makeSlices)
1001 {
1002  if (!makeSlices) return;
1003  for (int islice = 0; islice < s_innerNoBlades; ++islice)
1004  {
1005  double x = m_innerSliceOffset[islice].x();
1006  double y = m_innerSliceOffset[islice].y();
1007  double z = m_innerSliceOffset[islice].z();
1008  m_innerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
1009  m_innerWheel->add(m_innerSlice[islice]);
1010  }
1011 }
1012 
1014 //
1015 // Place Slices in Outer Wheel, if needed
1016 //
1017 void LArGeo::EMECAccordionConstruction::placeOuterSlices(bool makeSlices)
1018 {
1019  if (!makeSlices) return;
1020  for (int islice = 0; islice < s_outerNoBlades; ++islice)
1021  {
1022  double x = m_outerSliceOffset[islice].x();
1023  double y = m_outerSliceOffset[islice].y();
1024  double z = m_outerSliceOffset[islice].z();
1025  m_outerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
1026  m_outerWheel->add(m_outerSlice[islice]);
1027  }
1028 }
1029 
1031 //
1032 // Place Inner Wheel Electrodes and Absorbers
1033 //
1034 void
1035 LArGeo::EMECAccordionConstruction::placeInnerAccordion(int innerNoSectors,
1036  bool makeSlices,
1037  bool makeSectors)
1038 {
1039  int nphi = (makeSectors) ? m_innerNoElectrodes/innerNoSectors : m_innerNoElectrodes;
1040  double dphi = SI::twopi/m_innerNoElectrodes;
1041  GeoPhysVol* mother = nullptr;
1042 
1043  // Place Electordes
1044  for (int iphi = 0; iphi < nphi; ++iphi)
1045  {
1046  GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
1047  int copyNo = iphi + 1;
1048  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
1049  {
1050  if (makeSlices) mother = m_innerSlice[iblade];
1051  if (makeSectors) mother = m_innerSector[iblade];
1052  if (makeSlices || makeSectors)
1053  {
1054  double x = m_innerElectrodeOffset[iblade].x();
1055  double y = m_innerElectrodeOffset[iblade].y();
1056  double z = 0;
1057  GeoTrf::Translate3D translation(x, y, z);
1058  mother->add(new GeoIdentifierTag(copyNo));
1059  mother->add(new GeoTransform(rotation*translation));
1060  mother->add(m_innerElectrode[iblade]);
1061  }
1062  else
1063  {
1064  double x = m_innerElectrodeOffset[iblade].x();
1065  double y = m_innerElectrodeOffset[iblade].y();
1066  double z = m_innerElectrodeOffset[iblade].z();
1067  GeoTrf::Translate3D translation(x, y, z);
1068  m_innerWheel->add(new GeoIdentifierTag(copyNo));
1069  m_innerWheel->add(new GeoTransform(rotation*translation));
1070  m_innerWheel->add(m_innerElectrode[iblade]);
1071  }
1072  }
1073  }
1074 
1075  // Place Absorbers
1076  for (int iphi = 0; iphi < nphi; ++iphi)
1077  {
1078  GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
1079  int copyNo = iphi + 1;
1080  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
1081  {
1082  if (makeSlices) mother = m_innerSlice[iblade];
1083  if (makeSectors) mother = m_innerSector[iblade];
1084  if (makeSlices || makeSectors)
1085  {
1086  double x = m_innerAbsorberOffset[iblade].x();
1087  double y = m_innerAbsorberOffset[iblade].y();
1088  double z = 0;
1089  GeoTrf::Translate3D translation(x, y, z);
1090  mother->add(new GeoIdentifierTag(copyNo));
1091  mother->add(new GeoTransform(rotation*translation));
1092  mother->add(m_innerAbsorber[iblade]);
1093  }
1094  else
1095  {
1096  double x = m_innerAbsorberOffset[iblade].x();
1097  double y = m_innerAbsorberOffset[iblade].y();
1098  double z = m_innerAbsorberOffset[iblade].z();
1099  GeoTrf::Translate3D translation(x, y, z);
1100  m_innerWheel->add(new GeoIdentifierTag(copyNo));
1101  m_innerWheel->add(new GeoTransform(rotation*translation));
1102  m_innerWheel->add(m_innerAbsorber[iblade]);
1103  }
1104  }
1105  }
1106 }
1107 
1109 //
1110 // Place Outer Wheel Electrodes and Absorbers
1111 //
1112 void
1113 LArGeo::EMECAccordionConstruction::placeOuterAccordion(int outerNoSectors,
1114  bool makeSlices,
1115  bool makeSectors)
1116 {
1117  int nphi = (makeSectors) ? m_outerNoElectrodes/outerNoSectors : m_outerNoElectrodes;
1118  double dphi = SI::twopi/m_outerNoElectrodes;
1119  GeoPhysVol* mother = nullptr;
1120 
1121  // Place Electordes
1122  for (int iphi = 0; iphi < nphi; ++iphi)
1123  {
1124  GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
1125  int copyNo = iphi + 1;
1126  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
1127  {
1128  if (makeSlices) mother = m_outerSlice[iblade];
1129  if (makeSectors) mother = m_outerSector[iblade];
1130  if (makeSlices || makeSectors)
1131  {
1132  double x = m_outerElectrodeOffset[iblade].x();
1133  double y = m_outerElectrodeOffset[iblade].y();
1134  double z = 0;
1135  GeoTrf::Translate3D translation(x, y, z);
1136  mother->add(new GeoIdentifierTag(copyNo));
1137  mother->add(new GeoTransform(rotation*translation));
1138  mother->add(m_outerElectrode[iblade]);
1139  }
1140  else
1141  {
1142  double x = m_outerElectrodeOffset[iblade].x();
1143  double y = m_outerElectrodeOffset[iblade].y();
1144  double z = m_outerElectrodeOffset[iblade].z();
1145  GeoTrf::Translate3D translation(x, y, z);
1146  m_outerWheel->add(new GeoIdentifierTag(copyNo));
1147  m_outerWheel->add(new GeoTransform(rotation*translation));
1148  m_outerWheel->add(m_outerElectrode[iblade]);
1149  }
1150  }
1151  }
1152 
1153  // Place Absorbers
1154  for (int iphi = 0; iphi < nphi; ++iphi)
1155  {
1156  GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
1157  int copyNo = iphi + 1;
1158  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
1159  {
1160  if (makeSlices) mother = m_outerSlice[iblade];
1161  if (makeSectors) mother = m_outerSector[iblade];
1162  if (makeSlices || makeSectors)
1163  {
1164  double x = m_outerAbsorberOffset[iblade].x();
1165  double y = m_outerAbsorberOffset[iblade].y();
1166  double z = 0;
1167  GeoTrf::Translate3D translation(x, y, z);
1168  mother->add(new GeoIdentifierTag(copyNo));
1169  mother->add(new GeoTransform(rotation*translation));
1170  mother->add(m_outerAbsorber[iblade]);
1171  }
1172  else
1173  {
1174  double x = m_outerAbsorberOffset[iblade].x();
1175  double y = m_outerAbsorberOffset[iblade].y();
1176  double z = m_outerAbsorberOffset[iblade].z();
1177  GeoTrf::Translate3D translation(x, y, z);
1178  m_outerWheel->add(new GeoIdentifierTag(copyNo));
1179  m_outerWheel->add(new GeoTransform(rotation*translation));
1180  m_outerWheel->add(m_outerAbsorber[iblade]);
1181  }
1182  }
1183  }
1184 }
1185 
1187 //
1188 // Construct EMEC Inner Wheel Accordion
1189 //
1190 void
1191 LArGeo::EMECAccordionConstruction::constructInnerWheelStructure(bool makeSlices)
1192 {
1193  bool makeSectors = false;
1194  int innerNoSectors = 0;
1195 
1196  // P R E L I M I N A R Y C A L C U L A T I O N S
1197  //
1198  setInnerWheelSlices(); // define thickness of slices in Inner Wheel
1199 
1200  // Get enginneering data of absorbers
1201  double innerUncutBladeWidthMin, innerUncutBladeWidthMax;
1202  double innerLipLength1, innerLipPosition1;
1203  double innerLipLength2, innerLipPosition2;
1204  getInnerAbsorberData(innerUncutBladeWidthMin, innerUncutBladeWidthMax,
1205  innerLipLength1, innerLipPosition1,
1206  innerLipLength2, innerLipPosition2);
1207  innerUncutBladeWidthMin *= m_kContraction;
1208  innerUncutBladeWidthMax *= m_kContraction;
1209  innerLipLength1 *= m_kContraction;
1210  innerLipPosition1 *= m_kContraction;
1211  innerLipLength2 *= m_kContraction;
1212  innerLipPosition2 *= m_kContraction;
1213 
1214  // C O M P U T E U N C U T B L A D E C O R N E R S
1215  //
1216  double wmin, wmax, thickness, rmin, rmax, zdel;
1217 
1218  // Compute Inner Absorber Blade corners
1219  GeoThreeVector innerCorners[8];
1220  wmin = innerUncutBladeWidthMin;
1221  wmax = innerUncutBladeWidthMax;
1222  thickness = m_innerAbsorberThickness;
1223  rmin = m_innerWheelRmin[1];
1224  rmax = m_innerWheelRmax[s_innerNoBlades - 1];
1225  zdel = m_innerHalfWaveWidth; // slice width
1226  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerCorners);
1227 
1228  // Compute Inner Electrode Blade corners
1229  GeoThreeVector innerElectrodeCorners[8];
1230  thickness = m_innerElectrodeThickness;
1231  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerElectrodeCorners);
1232 
1233  // C O N S T R U C T L O G I C A L V O L U M E S
1234  //
1235  // Compute X-scale factors for glue and lead in absorbers
1236  // Needed for construction of corresponding volumes
1237  m_innerGlueRatio = (m_innerLeadThickness + 2*m_innerGlueThickness)/m_innerAbsorberThickness;
1238  m_innerLeadRatio = m_innerLeadThickness/m_innerAbsorberThickness;
1239 
1240  // Construct Lips, set offsets for the case "no Slices, no Sectors"
1241  constructInnerLips(innerLipLength1, innerLipPosition1, innerLipLength2, innerLipPosition2);
1242 
1243  // Construct Blades, set offsets for the case "no Slices, no Sectors"
1244  constructInnerBlades(innerCorners, innerElectrodeCorners);
1245 
1246  // Construct Slices, set offsets
1247  constructInnerSlices();
1248 
1249  // Construct Sectors (disabled)
1250  // constructInnerSectors(innerNoSectors);
1251 
1252  // C O N S T R U C T P H Y S I C A L V O L U M E S
1253  //
1254  placeInnerGlueAndLead(); // place Glue and Lead in Inner Wheel Absorbers
1255  placeInnerSlices(makeSlices); // place Slices, if needed
1256  // PlaceInnerSectors(innerNoSectors, makeSlices, makeSectors); // disabled
1257  placeInnerAccordion(innerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
1258 }
1259 
1261 //
1262 // Construct EMEC Inner Wheel Accordion
1263 //
1264 void
1265 LArGeo::EMECAccordionConstruction::constructOuterWheelStructure(bool makeSlices)
1266 {
1267  bool makeSectors = false;
1268  int outerNoSectors = 0;
1269 
1270  // P R E L I M I N A R Y C A L C U L A T I O N S
1271  //
1272  setOuterWheelSlices(); // define thickness of slices in Outer Wheel
1273 
1274  // Get enginneering data of absorbers
1275  double outerUncutBladeWidthMin, outerUncutBladeWidthMax;
1276  double outerLipLength1, outerLipPosition1;
1277  double outerLipLength2, outerLipPosition2;
1278  getOuterAbsorberData(outerUncutBladeWidthMin, outerUncutBladeWidthMax,
1279  outerLipLength1, outerLipPosition1,
1280  outerLipLength2, outerLipPosition2);
1281  outerUncutBladeWidthMin *= m_kContraction;
1282  outerUncutBladeWidthMax *= m_kContraction;
1283  outerLipLength1 *= m_kContraction;
1284  outerLipPosition1 *= m_kContraction;
1285  outerLipLength2 *= m_kContraction;
1286  outerLipPosition2 *= m_kContraction;
1287 
1288  // C O M P U T E U N C U T B L A D E C O R N E R S
1289  //
1290  double wmin, wmax, thickness, rmin, rmax, zdel;
1291 
1292  // Compute Outer Absorber Blade corners
1293  GeoThreeVector outerCorners[8];
1294  wmin = outerUncutBladeWidthMin;
1295  wmax = outerUncutBladeWidthMax;
1296  thickness = m_outerAbsorberThickness;
1297  rmin = m_outerWheelRmin[1];
1298  rmax = m_outerWheelRmax[s_outerNoBlades - 1];
1299  zdel = m_outerHalfWaveWidth; // slice width
1300  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerCorners);
1301 
1302  // Compute Outer Electrode Blade corners
1303  GeoThreeVector outerElectrodeCorners[8];
1304  thickness = m_outerElectrodeThickness;
1305  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerElectrodeCorners);
1306 
1307  // C O N S T R U C T L O G I C A L V O L U M E S
1308  //
1309  // Compute X-scale factors for glue and lead in absorbers
1310  // Needed for construction of corresponding volumes
1311  m_outerGlueRatio = (m_outerLeadThickness + 2*m_outerGlueThickness)/m_outerAbsorberThickness;
1312  m_outerLeadRatio = m_outerLeadThickness/m_outerAbsorberThickness;
1313 
1314  // Construct Lips, set offsets for the case "no Slices, no Sectors"
1315  constructOuterLips(outerLipLength1, outerLipPosition1, outerLipLength2, outerLipPosition2);
1316 
1317  // Construct Blades, set offsets for the case "no Slices, no Sectors"
1318  constructOuterBlades(outerCorners, outerElectrodeCorners);
1319 
1320  // Construct Slices, set offsets
1321  constructOuterSlices();
1322 
1323  // Construct Sectors (disabled)
1324  // constructOuterSectors(outerNoSectors);
1325 
1326  // C O N S T R U C T P H Y S I C A L V O L U M E S
1327  //
1328  placeOuterGlueAndLead(); // place Glue and Lead in Outer Wheel Absorbers
1329  placeOuterSlices(makeSlices); // place Slices, if needed
1330  // PlaceOuterSectors(outerNoSectors, makeSlices, makeSectors); // disabled
1331  placeOuterAccordion(outerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
1332 }
1333 
beamspotman.r
def r
Definition: beamspotman.py:676
LArGeo::EMECAccordionConstruction::m_innerNoElectrodes
int m_innerNoElectrodes
Definition: EMECAccordionConstruction.h:109
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ymin
double ymin
Definition: listroot.cxx:63
LArGeo::EMECAccordionConstruction::getOuterAbsorberData
void getOuterAbsorberData(double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
Definition: EMECAccordionConstruction.cxx:413
LArGeo::EMECAccordionConstruction::constructBlade
GeoShape * constructBlade(int icase, const GeoThreeVector corners[8], double xscale, double pz1, double pr1min, double pr1max, double pz2, double pr2min, double pr2max) const
Definition: EMECAccordionConstruction.cxx:597
LArGeo::EMECAccordionConstruction::setOuterWheel
void setOuterWheel(GeoFullPhysVol *outerWheel)
Definition: EMECAccordionConstruction.cxx:225
LArGeo::EMECAccordionConstruction::m_outerLeadThickness
double m_outerLeadThickness
Definition: EMECAccordionConstruction.h:159
LArGeo::EMECAccordionConstruction::CutPlane::m_d
double m_d
Definition: EMECAccordionConstruction.h:52
EMECAccordionConstruction.h
Declaration of EMECAccordionConstruction class.
LArGeo::EMECAccordionConstruction::CutPlane::m_n
GeoThreeVector m_n
Definition: EMECAccordionConstruction.h:51
LArGeo::EMECAccordionConstruction::getInnerAbsorberData
void getInnerAbsorberData(double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
Definition: EMECAccordionConstruction.cxx:339
IRDBAccessSvc::getRecordsetPtr
virtual IRDBRecordset_ptr getRecordsetPtr(const std::string &node, const std::string &tag, const std::string &tag2node="", const std::string &connName="ATLASDD")=0
Provides access to the Recordset object containing HVS-tagged data.
IGeoModelSvc
Definition: IGeoModelSvc.h:17
LArGeo::EMECAccordionConstruction::m_innerNoAbsorbes
int m_innerNoAbsorbes
Definition: EMECAccordionConstruction.h:110
LArGeo::EMECAccordionConstruction::m_innerGlueThickness
double m_innerGlueThickness
Definition: EMECAccordionConstruction.h:152
LArGeo::EMECAccordionConstruction::placeOuterAccordion
void placeOuterAccordion(int outerNoSectors, bool makeSlices, bool makeSectors)
Definition: EMECAccordionConstruction.cxx:1113
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:176
hist_file_dump.d
d
Definition: hist_file_dump.py:137
LArGeo::EMECAccordionConstruction::constructInnerBlades
void constructInnerBlades(const GeoThreeVector innerCorners[8], const GeoThreeVector innerElectrodeCorners[8])
Definition: EMECAccordionConstruction.cxx:879
LArGeo::EMECAccordionConstruction::constructOuterWheelStructure
void constructOuterWheelStructure(bool makeSlices=true)
Definition: EMECAccordionConstruction.cxx:1265
LArGeo::EMECAccordionConstruction::IntersectionPoint
GeoThreeVector IntersectionPoint(const GeoThreeVector &p1, const GeoThreeVector &p2, const CutPlane &plane) const
Definition: EMECAccordionConstruction.cxx:579
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
deg
#define deg
Definition: SbPolyhedron.cxx:17
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
DecodeVersionKey::node
const std::string & node() const
Return the version node.
Definition: DecodeVersionKey.cxx:99
LArGeo::EMECAccordionConstruction::m_outerHalfWaveWidth
double m_outerHalfWaveWidth
Definition: EMECAccordionConstruction.h:146
LArGeo::EMECAccordionConstruction::constructInnerLips
void constructInnerLips(double innerLipLength1, double innerLipPosition1, double innerLipLength2, double innerLipPosition2)
Definition: EMECAccordionConstruction.cxx:732
LArGeo::EMECAccordionConstruction::m_innerWaveWidth
double m_innerWaveWidth
Definition: EMECAccordionConstruction.h:137
LArGeo::EMECAccordionConstruction::getBottomCutPlane
CutPlane getBottomCutPlane(double zmin, double rmin, double zmax, double rmax) const
Definition: EMECAccordionConstruction.cxx:530
x
#define x
LArGeo::EMECAccordionConstruction::m_outerSteelThickness
double m_outerSteelThickness
Definition: EMECAccordionConstruction.h:160
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArGeo::EMECAccordionConstruction::m_innerAbsorberThickness
double m_innerAbsorberThickness
Definition: EMECAccordionConstruction.h:153
LArGeo::EMECAccordionConstruction::m_innerLeadThickness
double m_innerLeadThickness
Definition: EMECAccordionConstruction.h:150
LArGeo::EMECAccordionConstruction::setOuterWheelSlices
void setOuterWheelSlices()
Definition: EMECAccordionConstruction.cxx:284
LArGeo::EMECAccordionConstruction::getBladeCorners
void getBladeCorners(double wmin, double wmax, double thickness, double rmin, double rmax, double zdel, GeoThreeVector corners[8]) const
Definition: EMECAccordionConstruction.cxx:499
LArGeo::EMECAccordionConstruction::m_outerQuaterWaveWidth
double m_outerQuaterWaveWidth
Definition: EMECAccordionConstruction.h:147
LArGeo::EMECAccordionConstruction::m_innerHalfWaveWidth
double m_innerHalfWaveWidth
Definition: EMECAccordionConstruction.h:138
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
LArGeo::EMECAccordionConstruction::placeInnerGlueAndLead
void placeInnerGlueAndLead()
Definition: EMECAccordionConstruction.cxx:974
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:128
LArGeo::EMECAccordionConstruction::constructOuterBlades
void constructOuterBlades(const GeoThreeVector outerCorners[8], const GeoThreeVector outerElectrodeCorners[8])
Definition: EMECAccordionConstruction.cxx:927
LArGeo::EMECAccordionConstruction::m_outerNoWaves
int m_outerNoWaves
Definition: EMECAccordionConstruction.h:116
IRDBAccessSvc.h
Definition of the abstract IRDBAccessSvc interface.
LArGeo::EMECAccordionConstruction::m_innerWheelWidth
double m_innerWheelWidth
Definition: EMECAccordionConstruction.h:134
LArGeo::EMECAccordionConstruction::constructInnerSlices
void constructInnerSlices()
Definition: EMECAccordionConstruction.cxx:690
LArGeo::EMECAccordionConstruction::m_outerElectrodeThickness
double m_outerElectrodeThickness
Definition: EMECAccordionConstruction.h:163
LArGeo::EMECAccordionConstruction::placeInnerSlices
void placeInnerSlices(bool makeSlices)
Definition: EMECAccordionConstruction.cxx:1000
lumiFormat.i
int i
Definition: lumiFormat.py:85
xmin
double xmin
Definition: listroot.cxx:60
z
#define z
IRDBAccessSvc
IRDBAccessSvc is an abstract interface to the athena service that provides the following functionalit...
Definition: IRDBAccessSvc.h:45
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::rotation
rotation
Definition: TrackSurface_v1.cxx:15
LArGeo::EMECAccordionConstruction::setInnerWheel
void setInnerWheel(GeoFullPhysVol *innerWheel)
Definition: EMECAccordionConstruction.cxx:199
DecodeVersionKey
This is a helper class to query the version tags from GeoModelSvc and determine the appropriate tag a...
Definition: DecodeVersionKey.h:18
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:176
DecodeVersionKey::tag
const std::string & tag() const
Return version tag.
Definition: DecodeVersionKey.cxx:93
LArGeo::EMECAccordionConstruction::m_outerWaveWidth
double m_outerWaveWidth
Definition: EMECAccordionConstruction.h:145
LArGeo::EMECAccordionConstruction::placeInnerAccordion
void placeInnerAccordion(int innerNoSectors, bool makeSlices, bool makeSectors)
Definition: EMECAccordionConstruction.cxx:1035
GeoTwoVector
GeoTrf::Vector2D GeoTwoVector
Definition: EMECAccordionConstruction.h:21
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
min
#define min(a, b)
Definition: cfImp.cxx:40
twopi
constexpr double twopi
Definition: VertexPointEstimator.cxx:16
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
LArGeo::EMECAccordionConstruction::m_outerGlueThickness
double m_outerGlueThickness
Definition: EMECAccordionConstruction.h:161
LArGeo::EMECAccordionConstruction::setMaterial
void setMaterial(const std::string &name, const GeoMaterial *material)
Definition: EMECAccordionConstruction.cxx:320
LArGeo::EMECAccordionConstruction::m_kContraction
double m_kContraction
Definition: EMECAccordionConstruction.h:168
LArGeo::EMECAccordionConstruction::m_outerAbsorberThickness
double m_outerAbsorberThickness
Definition: EMECAccordionConstruction.h:162
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
LArGeo::EMECAccordionConstruction::getTopCutPlane
CutPlane getTopCutPlane(double zmin, double rmin, double zmax, double rmax, const GeoThreeVector corners[8]) const
Definition: EMECAccordionConstruction.cxx:548
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
DecodeVersionKey.h
LArGeo::EMECAccordionConstruction::m_outerLipWidth
double m_outerLipWidth
Definition: EMECAccordionConstruction.h:143
GeoThreeVector
GeoTrf::Vector3D GeoThreeVector
Definition: EMECAccordionConstruction.h:22
LArGeo::EMECAccordionConstruction::m_outerWheelWidth
double m_outerWheelWidth
Definition: EMECAccordionConstruction.h:142
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
python.PyAthena.v
v
Definition: PyAthena.py:154
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
LArGeo::EMECAccordionConstruction::CutPlane
Definition: EMECAccordionConstruction.h:50
LArGeo::EMECAccordionConstruction::m_innerQuaterWaveWidth
double m_innerQuaterWaveWidth
Definition: EMECAccordionConstruction.h:139
LArGeo::EMECAccordionConstruction::constructOuterLips
void constructOuterLips(double outerLipLength1, double outerLipPosition1, double outerLipLength2, double outerLipPosition2)
Definition: EMECAccordionConstruction.cxx:805
LArGeo::EMECAccordionConstruction::m_innerLipWidth
double m_innerLipWidth
Definition: EMECAccordionConstruction.h:135
IRDBRecord.h
Definition of the abstract IRDBRecord interface.
y
#define y
LArGeo::EMECAccordionConstruction::m_outerNoElectrodes
int m_outerNoElectrodes
Definition: EMECAccordionConstruction.h:114
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
xmax
double xmax
Definition: listroot.cxx:61
LArGeo::EMECAccordionConstruction::placeOuterGlueAndLead
void placeOuterGlueAndLead()
Definition: EMECAccordionConstruction.cxx:987
LArGeo::EMECAccordionConstruction::m_innerNoWaves
int m_innerNoWaves
Definition: EMECAccordionConstruction.h:111
LArGeo::EMECAccordionConstruction::constructInnerWheelStructure
void constructInnerWheelStructure(bool makeSlices=true)
Definition: EMECAccordionConstruction.cxx:1191
LArGeo::EMECAccordionConstruction::m_outerNoAbsorbes
int m_outerNoAbsorbes
Definition: EMECAccordionConstruction.h:115
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
IRDBRecordset.h
Definition of the abstract IRDBRecordset interface.
python.PhysicalConstants.halfpi
float halfpi
Definition: PhysicalConstants.py:51
IGeoModelSvc.h
LArGeo::EMECAccordionConstruction::m_outerWaveZoneWidth
double m_outerWaveZoneWidth
Definition: EMECAccordionConstruction.h:144
StoreGateSvc.h
LArGeo::EMECAccordionConstruction::m_innerWaveZoneWidth
double m_innerWaveZoneWidth
Definition: EMECAccordionConstruction.h:136
LArGeo::EMECAccordionConstruction::setInnerWheelSlices
void setInnerWheelSlices()
Definition: EMECAccordionConstruction.cxx:252
IGeoDbTagSvc.h
LArGeo::EMECAccordionConstruction::setWheelParameters
void setWheelParameters()
Definition: EMECAccordionConstruction.cxx:51
LArGeo::EMECAccordionConstruction::m_innerSteelThickness
double m_innerSteelThickness
Definition: EMECAccordionConstruction.h:151
LArGeo::EMECAccordionConstruction::constructOuterSlices
void constructOuterSlices()
Definition: EMECAccordionConstruction.cxx:710
LArGeo::EMECAccordionConstruction::placeOuterSlices
void placeOuterSlices(bool makeSlices)
Definition: EMECAccordionConstruction.cxx:1017
ymax
double ymax
Definition: listroot.cxx:64
LArGeo::EMECAccordionConstruction::m_innerElectrodeThickness
double m_innerElectrodeThickness
Definition: EMECAccordionConstruction.h:154
Generated on Tue Oct 1 2024 21:14:44 for ATLAS Offline Software by   doxygen 1.8.18