ATLAS Offline Software
LArWheelCalculator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // LArWheelCalculator 19-Apr-2001 Bill Seligman
6 // 26-May-2009 AMS: remove all previous comments from here as obsoleted
7 
8 #include <cmath>
9 #include <climits>
10 #include <cassert>
11 #ifndef PORTABLE_LAR_SHAPE
12 #include "GaudiKernel/Bootstrap.h"
13 #include "GaudiKernel/ISvcLocator.h"
14 #include "GaudiKernel/MsgStream.h"
15 #else
16 #include "PortableMsgStream/PortableMsgStream.h"
17 #endif
18 
19 #include "GeoSpecialShapes/LArWheelCalculator.h"
20 #include "GeoSpecialShapes/EMECData.h"
21 
22 #include "./LArWheelCalculator_Impl/DistanceCalculatorFactory.h"
23 #include "./LArWheelCalculator_Impl/FanCalculatorFactory.h"
24 
25 
26 #include "GeoModelKernel/Units.h"
27 
28 using namespace GeoModelKernelUnits;
29 
30 
31 // these numbers are taken from DB in constructor,
32 // hardcoded values here are just for reference
33 /*
34  double LArWheelCalculator::zWheelRefPoint = 3689.5*mm; //=endg_z0
35  double LArWheelCalculator::dMechFocaltoWRP = 3691. *mm; //=endg_z1
36  double LArWheelCalculator::dElecFocaltoWRP = 3689. *mm; //=endg_dcf
37  double LArWheelCalculator::rOuterCutoff = 2034. *mm; //=endg_rlimit
38  double LArWheelCalculator::HalfGapBetweenWheels = 0.15*cm; // In DB EMECGEOMETRY.DCRACK
39  float LArWheelCalculator::m_zShift = 4. *cm; // endg_zshift
40  double LArWheelCalculator::eta_hi = 3.2; // from EmecWheelParameters
41  double LArWheelCalculator::eta_mid = 2.5;
42  double LArWheelCalculator::eta_low = 1.375;
43 */
44 
45 // these values are taken from "EMECParams" DB
46 /*
47  bool LArWheelCalculator::SaggingOn = false;
48  bool LArWheelCalculator::phiRotation = false;
49 */
50 
51 // these were internal constants, now everything in DB
52 //const double LArWheelCalculator::s_dWRPtoFrontFace = 11.*mm;
53 //const double LArWheelCalculator::s_WheelThickness = 514.*mm;
54 // 2x2mm are to be substracted from value of wheel thickness
55 // - for straight 2-mm domains at start and finish of absorber
56 //const double LArWheelCalculator::s_StraightStartSection = 2.*mm;
57 //const double LArWheelCalculator::s_HalfWheelThickness = s_WheelThickness * 0.5;
58 //const double LArWheelCalculator::s_WheelThickness_wo_2sss = s_WheelThickness - 2.*s_StraightStartSection;
59 
60 static const double default_slant_parametrization[2][5] = {
61  { -50.069, 0.50073, -0.10127E-02, 0.10390E-05, -0.42176E-09 }, // inner
62  { -34.254, 0.15528, -0.11670E-03, 0.45018E-07, -0.68473E-11 } //outer
63 };
64 
65 const char *LArWheelCalculator::LArWheelCalculatorTypeString(LArG4::LArWheelCalculator_t type)
66 {
67  switch(type){
68  case LArG4::InnerAbsorberWheel: return("InnerAbsorberWheel");
69  case LArG4::OuterAbsorberWheel: return("OuterAbsorberWheel");
70  case LArG4::InnerElectrodWheel: return("InnerElectrodWheel");
71  case LArG4::OuterElectrodWheel: return("OuterElectrodWheel");
72  case LArG4::InnerAbsorberModule: return("InnerAbsorberModule");
73  case LArG4::OuterAbsorberModule: return("OuterAbsorberModule");
74  case LArG4::InnerElectrodModule: return("InnerElectrodModule");
75  case LArG4::OuterElectrodModule: return("OuterElectrodModule");
76  case LArG4::BackOuterBarretteWheel: return("BackOuterBarretteWheel");
77  case LArG4::BackInnerBarretteWheel: return("BackInnerBarretteWheel");
78  case LArG4::BackOuterBarretteModule: return("BackOuterBarretteModule");
79  case LArG4::BackInnerBarretteModule: return("BackInnerBarretteModule");
80  case LArG4::BackOuterBarretteWheelCalib: return("BackOuterBarretteWheelCalib");
81  case LArG4::BackInnerBarretteWheelCalib: return("BackInnerBarretteWheelCalib");
82  case LArG4::BackOuterBarretteModuleCalib: return("BackOuterBarretteModuleCalib");
83  case LArG4::BackInnerBarretteModuleCalib: return("BackInnerBarretteModuleCalib");
84  case LArG4::InnerGlueWheel: return("InnerGlueWheel");
85  case LArG4::InnerLeadWheel: return("InnerLeadWheel");
86  case LArG4::OuterGlueWheel: return("OuterGlueWheel");
87  case LArG4::OuterLeadWheel: return("OuterLeadWheel");
88  }
89  return("unknown");
90 }
91 
92 LArWheelCalculator::~LArWheelCalculator() {
93  delete m_distanceCalcImpl;
94  m_distanceCalcImpl = 0;
95  delete m_fanCalcImpl;
96  m_fanCalcImpl = 0;
97 }
98 
99 LArWheelCalculator::LArWheelCalculator(const EMECData & emecData, LArG4::LArWheelCalculator_t a_wheelType, int zside) :
100  m_type(a_wheelType),
101  m_AtlasZside(zside),
102  m_distanceCalcImpl(0),
103  m_fanCalcImpl(0)
104 {
105 
106 #ifndef PORTABLE_LAR_SHAPE
107  // Get pointer to the message service
108  SmartIF<IMessageSvc> msgSvc{Gaudi::svcLocator()->service("MessageSvc")};
109  if(!msgSvc.isValid()){
110  throw std::runtime_error("LArWheelCalculator constructor: cannot initialze message service");
111  }
112  MsgStream msg(msgSvc, "LArWheelCalculator");
113 #else
114  PortableMsgStream msg("LArWheelCalculator");
115 #endif
116  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
117  << " (type " << LArWheelCalculatorTypeString(m_type)
118  << "):" << endmsg;
119 
120 
121  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
122  << " (type " << LArWheelCalculatorTypeString(m_type)
123  << "):" << endmsg;
124 
125 #ifdef LARWC_DTNF_NEW
126  msg << MSG::VERBOSE << "compiled with new DTNF" << endmsg;
127 #endif
128 
129  // Access source of detector parameters.
130  msg << MSG::VERBOSE
131  << "initializing data members from DB..." << endmsg;
132 
133  m_zWheelRefPoint =emecData.emecgeometry[0].Z0*cm;
134  m_dMechFocaltoWRP =emecData.emecgeometry[0].Z1*cm;
135  m_dElecFocaltoWRP =emecData.emecgeometry[0].DCF*cm;
136  m_HalfGapBetweenWheels =emecData.emecgeometry[0].DCRACK*cm;
137  m_rOuterCutoff =emecData.emecgeometry[0].RLIMIT*cm;
138  m_zShift =emecData.emecgeometry[0].ZSHIFT*cm;
139 
140 
141  m_eta_hi =emecData.emecwheelparameters[0].ETAINT;
142  m_eta_mid =emecData.emecwheelparameters[0].ETAEXT;
143  m_eta_low =emecData.emecwheelparameters[1].ETAEXT;
144 
145 
146 
147  m_leadThicknessInner=emecData.emecfan[0].LEADTHICKNESSINNER*mm;
148  m_leadThicknessOuter=emecData.emecfan[0].LEADTHICKNESSOUTER*mm;
149  m_steelThickness=emecData.emecfan[0].STEELTHICKNESS*mm;
150  m_glueThickness=emecData.emecfan[0].GLUETHICKNESS*mm;
151  m_electrodeTotalThickness=emecData.emecfan[0].ELECTRODETOTALTHICKNESS*mm;
152  m_coldContraction=emecData.coldcontraction[0].ABSORBERCONTRACTION;
153  m_electrodeInvContraction=emecData.coldcontraction[0].ELECTRODEINVCONTRACTION;
154 
155 
156 
157  m_ActiveLength =emecData.emecmagicnumbers[0].ACTIVELENGTH*mm;
158  m_StraightStartSection =emecData.emecmagicnumbers[0].STRAIGHTSTARTSECTION*mm;
159  m_dWRPtoFrontFace =emecData.emecmagicnumbers[0].REFTOACTIVE*mm;
160 
161 
162  m_WheelThickness = m_ActiveLength + 2.*m_StraightStartSection;
163  m_HalfWheelThickness = m_WheelThickness * 0.5;
164 
165  std::string pr_opt_value=emecData.emecparams[0].PHIROTATION;
166  std::string sagging_opt_value=emecData.emecparams[0].SAGGING;
167 
168  m_phiRotation = pr_opt_value == "g3"? true: false;
169 
170  m_zWheelFrontFace = m_dMechFocaltoWRP + m_dWRPtoFrontFace;
171  m_zWheelBackFace = m_zWheelFrontFace + m_WheelThickness;
172 
173  msg << MSG::DEBUG << "... got these values:" << endmsg
174  << "m_zWheelRefPoint : " << m_zWheelRefPoint / cm << " [cm]" << endmsg
175  << "m_dMechFocaltoWRP : " << m_dMechFocaltoWRP / cm << " [cm]" << endmsg
176  << "m_dElecFocaltoWRP : " << m_dElecFocaltoWRP / cm << " [cm]" << endmsg
177  << "m_HalfGapBetweenWheels : " << m_HalfGapBetweenWheels / cm << " [cm]" << endmsg
178  << "m_rOuterCutoff : " << m_rOuterCutoff / cm << " [cm]" << endmsg
179  << "m_zWheelFrontFace : " << m_zWheelFrontFace / cm << " [cm]" << endmsg
180  << "m_zWheelBackFace : " << m_zWheelBackFace / cm << " [cm]" << endmsg
181  << "m_zShift : " << m_zShift / cm << " [cm]" << endmsg
182  << "Phi rotation : " << (m_phiRotation? "true": "false") << "" << endmsg
183  << "eta wheels limits : " << m_eta_low << ", " << m_eta_mid << ", " << m_eta_hi
184  << endmsg;
185  msg << MSG::VERBOSE << "hardcoded constants: " << endmsg
186  << "m_WheelThickness : " << m_WheelThickness / cm << " [cm]" << endmsg
187  << "m_dWRPtoFrontFace : " << m_dWRPtoFrontFace / cm << " [cm]"
188  << endmsg;
189 
190 
191  // Constructor initializes the geometry.
192 
193  m_isBarrette = false;
194  m_isBarretteCalib = false;
195  m_isModule = false;
196  m_isElectrode = false;
197  m_isInner = false;
198  m_FirstFan = 0;
199  m_LastFan = 0;
200 
201  switch(m_type){
202  case LArG4::BackInnerBarretteWheelCalib:
203  m_isBarretteCalib = true;
204  /* FALLTHROUGH */
205  case LArG4::BackInnerBarretteWheel:
206  m_isBarrette = true;
207  m_type = LArG4::InnerAbsorberWheel;
208  /* FALLTHROUGH */
209  case LArG4::InnerAbsorberWheel:
210  case LArG4::InnerGlueWheel:
211  case LArG4::InnerLeadWheel:
212  inner_wheel_init(emecData);
213  m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
214  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
215  break;
216  case LArG4::BackOuterBarretteWheelCalib:
217  m_isBarretteCalib = true;
218  /* FALLTHROUGH */
219  case LArG4::BackOuterBarretteWheel:
220  m_isBarrette = true;
221  m_type = LArG4::OuterAbsorberWheel;
222  /* FALLTHROUGH */
223  case LArG4::OuterAbsorberWheel:
224  case LArG4::OuterGlueWheel:
225  case LArG4::OuterLeadWheel:
226  outer_wheel_init(emecData);
227  m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
228  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
229  break;
230  case LArG4::InnerElectrodWheel:
231  inner_wheel_init(emecData);
232  m_ZeroFanPhi = 0;
233  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
234  m_isElectrode = true;
235  break;
236  case LArG4::OuterElectrodWheel:
237  outer_wheel_init(emecData);
238  m_ZeroFanPhi = 0;
239  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
240  m_isElectrode = true;
241  break;
242  case LArG4::BackInnerBarretteModuleCalib:
243  m_isBarretteCalib = true;
244  /* FALLTHROUGH */
245  case LArG4::BackInnerBarretteModule:
246  m_isBarrette = true;
247  m_type = LArG4::InnerAbsorberModule;
248  /* FALLTHROUGH */
249  case LArG4::InnerAbsorberModule:
250  inner_wheel_init(emecData);
251  module_init();
252  m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
253  // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
254  break;
255  case LArG4::BackOuterBarretteModuleCalib:
256  m_isBarretteCalib = true;
257  /* FALLTHROUGH */
258  case LArG4::BackOuterBarretteModule:
259  m_isBarrette = true;
260  m_type = LArG4::OuterAbsorberModule;
261  /* FALLTHROUGH */
262  case LArG4::OuterAbsorberModule:
263  outer_wheel_init(emecData);
264  module_init();
265  m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
266  // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
267  break;
268  case LArG4::InnerElectrodModule:
269  inner_wheel_init(emecData);
270  module_init();
271  m_FirstFan ++;
272  m_isElectrode = true;
273  break;
274  case LArG4::OuterElectrodModule:
275  outer_wheel_init(emecData);
276  module_init();
277  m_FirstFan ++;
278  m_isElectrode = true;
279  break;
280  default:
281  throw std::runtime_error("LArWheelCalculator constructor:unknown LArWheelCalculator_t");
282  }
283  m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
284  m_NumberOfHalfWaves = m_NumberOfWaves * 2;
285  m_HalfWaveLength = m_ActiveLength / m_NumberOfHalfWaves;
286  m_QuarterWaveLength = m_HalfWaveLength * 0.5;
287  //m_HalfNumberOfFans = m_NumberOfFans / 2;
288  m_FanHalfThickness = GetFanHalfThickness(m_type);
289 
290  // Init sagging
291  // value read above
292  // std::string sagging_opt_value = (*DB_EMECParams)[0]->getString("SAGGING");
293 
294  msg << MSG::VERBOSE << "SAGGING value = " << sagging_opt_value << endmsg;
295 
296  // the same condition is in DistanceCalculatorFactory::Create
297  m_SaggingOn = (sagging_opt_value != "" && sagging_opt_value != "off")? true: false;
298 
299  m_distanceCalcImpl = LArWheelCalculator_Impl::DistanceCalculatorFactory::Create(
300  sagging_opt_value, this);
301  if (m_SaggingOn) {
302  msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOn = " << this
303  << ',' << m_distanceCalcImpl << endmsg;
304  } else {
305  msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOff = " << this
306  << ',' << m_distanceCalcImpl << endmsg;
307  }
308 
309  m_fanCalcImpl = LArWheelCalculator_Impl::FanCalculatorFactory::Create(
310  m_SaggingOn, m_isModule, this);
311 
312  //--------------------------
313  // At this place there was the loading of sagging parameters
314  // Transfered to DistanceCalculatorSaggingOn
315  //--------------------------
316 
317  // Get option: Slant params.
318  msg << MSG::VERBOSE << "Loading SlantAngle parameters ...";
319  std::string slant_params;
320 
321  if (m_isInner) {
322  slant_params=emecData.emecparams[0].INNERSLANTPARAM;
323  } else {
324  slant_params=emecData.emecparams[0].OUTERSLANTPARAM;
325  }
326 
327  msg << (m_isInner?" InnerWheel ":" OuterWheel ") << slant_params << endmsg;
328 
329  if(slant_params != "" && slant_params != "default"){
330  double a, b, c, d, e;
331  if(sscanf(slant_params.c_str(), "%80le %80le %80le %80le %80le", &a, &b, &c, &d, &e) != 5){
332  msg << MSG::ERROR
333  << "LArWheelCalculator: ERROR: wrong value(s) "
334  << "for EMEC slant angle parameters: "
335  << slant_params << ", "
336  << "defaults are used" << endmsg;
337  } else {
338  m_slant_parametrization[0] = a;
339  m_slant_parametrization[1] = b;
340  m_slant_parametrization[2] = c;
341  m_slant_parametrization[3] = d;
342  m_slant_parametrization[4] = e;
343  m_slant_use_default = false;
344  }
345  } // else already initialized in inner/outer_wheel_init()
346 
347  fill_sincos_parameterization(); // initialize sin&cos parameterization
348 
349  msg << MSG::VERBOSE << "All params initialized. Print some internal variables" << endmsg;
350 
351  msg << MSG::VERBOSE << "Data members:" << endmsg
352  << "m_AtlasZside = " << m_AtlasZside << "" << endmsg
353  << "m_NumberOfFans = " << m_NumberOfFans << "" << endmsg
354  << "m_ZeroFanPhi = " << m_ZeroFanPhi << "" << endmsg
355  << "m_ZeroFanPhi_ForDetNeaFan = " << m_ZeroFanPhi_ForDetNeaFan << "" << endmsg
356  << "m_FanStepOnPhi = " << m_FanStepOnPhi << "" << endmsg
357  << "m_FanHalfThickness = " << m_FanHalfThickness << "" << endmsg
358  //<< "Sagging parameters : " << m_sagging_parameter[0][0] << " " << m_sagging_parameter[0][1] << "" << endmsg
359  //<< "Sagging parameters : " << m_sagging_parameter[1][0] << " " << m_sagging_parameter[1][1] << "" << endmsg
360  << "slant_params = " << slant_params << "" << endmsg
361  << "Sagging option = " << sagging_opt_value << "" << endmsg
362  << "SaggingOn = " << (m_SaggingOn? "true": "false") << "" << endmsg
363  << "Slant parameters : ";
364  for(int i = 0; i < 5; i ++) msg << " " << m_slant_parametrization[i];
365  msg << endmsg;
366 
367  if(m_isModule){
368  msg << MSG::VERBOSE
369  << "module_init: FirstFan = " << m_FirstFan
370  << ", LastFan = " << m_LastFan
371  << ", ZeroFanPhi = " << m_ZeroFanPhi
372  << endmsg;
373  }
374 
375  //m_fan_number = -1000;
376 
377  // Is the following code fragment obsoleted? DM 2015-03-13
378  /* to compare various methods of slant angle computation:
379  if(isInner) return;
380  FILE *O = fopen("slant_stat.table1.txt", "w");
381  if(O == 0) abort();
382  struct timeval t1, t2;
383  struct timezone tz;
384  std::vector<double> alpha;
385  gettimeofday(&t1, &tz);
386  for(double r = 600.; r < 2100.; r += .01){
387  alpha.push_back(parameterized_slant_angle(r));
388  }
389  gettimeofday(&t2, &tz);
390 
391  fprintf(O, "%d.%06d %d.%06d" << endmsg, t1.tv_sec, t1.tv_usec, t2.tv_sec, t2.tv_usec);
392  int i = 0;
393  for(double r = 600.; r < 2100.; r += .01, i ++){
394  fprintf(O, "%f %f\n", r, alpha[i]);
395  }
396 
397  fclose(O);
398  exit(0);
399  */
400 }
401 
402 /* converts module gap number into wheel gap number */
403 int LArWheelCalculator::PhiGapNumberForWheel(int i) const
404 {
405  return m_fanCalcImpl->PhiGapNumberForWheel(i);
406 }
407 
408 void LArWheelCalculator::inner_wheel_init(const EMECData & emecData)
409 {
410  for(int i = 0; i < 5; ++ i) {
411  m_slant_parametrization[i] = default_slant_parametrization[0][i];
412  }
413  m_slant_use_default = true;
414 
415  m_NumberOfFans=emecData.emecwheelparameters[0].NABS;
416  m_NumberOfWaves=emecData.emecwheelparameters[0].NACC;
417 
418  m_FanFoldRadius = 3.25*mm;
419  m_ZeroGapNumber = 64; // internal constant, should not be taken from DB
420  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
421  m_isInner = true;
422 }
423 
424 void LArWheelCalculator::outer_wheel_init(const EMECData & emecData)
425 {
426  for(int i = 0; i < 5; ++ i) {
427  m_slant_parametrization[i] = default_slant_parametrization[1][i];
428  }
429  m_slant_use_default = true;
430 
431  m_NumberOfFans=emecData.emecwheelparameters[1].NABS;
432  m_NumberOfWaves=emecData.emecwheelparameters[1].NACC;
433 
434 
435  m_FanFoldRadius = 3.0*mm;
436  m_ZeroGapNumber = 192; // internal constant, should not be taken from DB
437  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
438  m_isInner = false;
439 }
440 
441 double LArWheelCalculator::GetFanHalfThickness(LArG4::LArWheelCalculator_t t) const
442 {
443 
444  switch(t){
445  case LArG4::BackInnerBarretteWheelCalib:
446  case LArG4::BackInnerBarretteModuleCalib:
447  case LArG4::BackInnerBarretteWheel:
448  case LArG4::BackInnerBarretteModule:
449  case LArG4::InnerAbsorberWheel:
450  case LArG4::InnerAbsorberModule:
451  return (m_leadThicknessInner / 2 + m_steelThickness + m_glueThickness)*m_coldContraction; // new values, 02.11.06 J.T. with contraction in cold
452  // lead / 2 + steel + glue
453  case LArG4::InnerGlueWheel:
454  return (m_leadThicknessInner / 2 + m_glueThickness)*m_coldContraction;
455  case LArG4::InnerLeadWheel:
456  return m_leadThicknessInner / 2 * m_coldContraction;
457 
458  case LArG4::BackOuterBarretteWheelCalib:
459  case LArG4::BackOuterBarretteModuleCalib:
460  case LArG4::BackOuterBarretteWheel:
461  case LArG4::BackOuterBarretteModule:
462  case LArG4::OuterAbsorberWheel:
463  case LArG4::OuterAbsorberModule:
464  return (m_leadThicknessOuter / 2 + m_steelThickness + m_glueThickness)*m_coldContraction; // new values, 02.11.06 J.T.
465  case LArG4::OuterGlueWheel:
466  return (m_leadThicknessOuter / 2 + m_glueThickness)*m_coldContraction;
467  case LArG4::OuterLeadWheel:
468  return m_leadThicknessOuter / 2 * m_coldContraction;
469 
470  case LArG4::InnerElectrodWheel:
471  case LArG4::OuterElectrodWheel:
472  case LArG4::InnerElectrodModule:
473  case LArG4::OuterElectrodModule:
474  return m_electrodeTotalThickness/m_electrodeInvContraction * 0.5; //new values, 02.11.06 J.T
475  }
476  throw std::runtime_error("LArWheelCalculator::GetFanHalfThickness: wrong wheel type");
477 }
478 
479 void LArWheelCalculator::module_init()
480 {
481  m_isModule = true;
482  m_LastFan = m_NumberOfFans / 8;
483  m_FirstFan = 0;
484  m_ZeroFanPhi = - m_LastFan / 2 * m_FanStepOnPhi;
485 }
486 
487 /*
488  array of r is filled with:
489  for inner wheel - 2 elements { r_front, r_back }
490  for outer wheel - 3 elements { r_front, r_middle, r_back }
491  return value - delta_z of middle point in case of outer wheel
492 */
493 double LArWheelCalculator::GetWheelInnerRadius(std::array<double,2> & r) const
494 {
495  double zMid = 0.;
496  if(m_isInner){
497  double tanThetaInner = 2. * exp(-m_eta_hi ) / (1. - exp(-2.*m_eta_hi ));
498  r[0] = m_zWheelFrontFace * tanThetaInner;
499  r[1] = m_zWheelBackFace * tanThetaInner;
500  }
501  return zMid;
502 }
503 
504 double LArWheelCalculator::GetWheelInnerRadius(std::array<double,3> & r) const
505 {
506  double zMid = 0.;
507  if (not m_isInner){
508  double tanThetaMid = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
509  double inv_tanThetaOuter = (1. - exp(-2.*m_eta_low)) / (2. * exp(-m_eta_low));
510  // Note that there is a 3mm gap between the outer surface of the
511  // inner wheel and the inner surface of the outer wheel.
512  r[0] = m_zWheelFrontFace * tanThetaMid + m_HalfGapBetweenWheels;
513  r[1] = m_rOuterCutoff * inv_tanThetaOuter * tanThetaMid + m_HalfGapBetweenWheels;
514  r[2] = m_zWheelBackFace * tanThetaMid + m_HalfGapBetweenWheels;
515  zMid = m_rOuterCutoff * inv_tanThetaOuter - m_zWheelFrontFace;
516  }
517  return zMid;
518 }
519 
520 /*
521  array of r is filled with:
522  for inner wheel - 2 elements { r_front, r_back }
523  for outer wheel - 3 elements { r_front, r_middle, r_back }
524 */
525 void LArWheelCalculator::GetWheelOuterRadius(std::array<double,2> & r) const
526 {
527  if(m_isInner){
528  double tanThetaMid = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
529  // Note that there is a 3mm gap between the outer surface of the
530  // inner wheel and the inner surface of the outer wheel.
531  r[0] = m_zWheelFrontFace * tanThetaMid - m_HalfGapBetweenWheels;
532  r[1] = m_zWheelBackFace * tanThetaMid - m_HalfGapBetweenWheels;
533  }
534 }
535 void LArWheelCalculator::GetWheelOuterRadius(std::array<double,3> & r) const
536 {
537  if(not m_isInner){
538  double tanThetaOuter = 2. * exp(-m_eta_low) / (1. - exp(-2.*m_eta_low));
539  r[0] = m_zWheelFrontFace * tanThetaOuter;
540  r[1] = m_rOuterCutoff;
541  r[2] = m_rOuterCutoff;
542  }
543 }
LArWheelCalculator::m_dMechFocaltoWRP
double m_dMechFocaltoWRP
Definition: LArWheelCalculator.h:162
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
beamspotman.r
def r
Definition: beamspotman.py:676
LArWheelCalculator::m_rOuterCutoff
double m_rOuterCutoff
Definition: LArWheelCalculator.h:164
LArG4::BackOuterBarretteModule
@ BackOuterBarretteModule
Definition: LArWheelCalculatorEnums.h:17
LArWheelCalculator_Impl::FanCalculatorFactory::Create
static IFanCalculator * Create(bool isSaggingOn, bool isModule, LArWheelCalculator *lwc)
Definition: FanCalculatorFactory.cxx:13
LArG4::OuterElectrodWheel
@ OuterElectrodWheel
Definition: LArWheelCalculatorEnums.h:12
LArWheelCalculator::m_electrodeTotalThickness
double m_electrodeTotalThickness
Definition: LArWheelCalculator.h:198
LArWheelCalculator::module_init
void module_init()
Definition: LArWheelCalculator.cxx:479
LArWheelCalculator::m_eta_low
double m_eta_low
Definition: LArWheelCalculator.h:165
LArWheelCalculator_Impl::IFanCalculator::PhiGapNumberForWheel
virtual int PhiGapNumberForWheel(int i) const =0
LArWheelCalculator::m_glueThickness
double m_glueThickness
Definition: LArWheelCalculator.h:197
EMECData.h
LArWheelCalculator::m_isModule
bool m_isModule
Definition: LArWheelCalculator.h:187
LArG4::InnerAbsorberWheel
@ InnerAbsorberWheel
Definition: LArWheelCalculatorEnums.h:11
LArWheelCalculator::m_slant_use_default
bool m_slant_use_default
Definition: LArWheelCalculator.h:151
hist_file_dump.d
d
Definition: hist_file_dump.py:137
LArG4::InnerGlueWheel
@ InnerGlueWheel
Definition: LArWheelCalculatorEnums.h:19
LArWheelCalculator::m_dElecFocaltoWRP
double m_dElecFocaltoWRP
Definition: LArWheelCalculator.h:163
LArWheelCalculator::m_electrodeInvContraction
double m_electrodeInvContraction
Definition: LArWheelCalculator.h:200
LArWheelCalculator::m_eta_mid
double m_eta_mid
Definition: LArWheelCalculator.h:165
EMECData
Definition: EMECData.h:131
LArWheelCalculator::inner_wheel_init
void inner_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:408
LArWheelCalculator::LArWheelCalculatorTypeString
static const char * LArWheelCalculatorTypeString(LArG4::LArWheelCalculator_t)
Definition: LArWheelCalculator.cxx:65
M_PI
#define M_PI
Definition: ActiveFraction.h:11
LArWheelCalculator::PhiGapNumberForWheel
int PhiGapNumberForWheel(int) const
Definition: LArWheelCalculator.cxx:403
LArWheelCalculator::m_FanHalfThickness
double m_FanHalfThickness
Definition: LArWheelCalculator.h:182
LArG4::InnerAbsorberModule
@ InnerAbsorberModule
Definition: LArWheelCalculatorEnums.h:13
LArWheelCalculator::m_fanCalcImpl
LArWheelCalculator_Impl::IFanCalculator * m_fanCalcImpl
Definition: LArWheelCalculator.h:238
LArG4::OuterElectrodModule
@ OuterElectrodModule
Definition: LArWheelCalculatorEnums.h:14
LArWheelCalculator::m_leadThicknessOuter
double m_leadThicknessOuter
Definition: LArWheelCalculator.h:195
LArWheelCalculator::m_AtlasZside
int m_AtlasZside
Definition: LArWheelCalculator.h:148
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
LArWheelCalculator::m_zWheelFrontFace
double m_zWheelFrontFace
Definition: LArWheelCalculator.h:170
EMECData::emecfan
std::vector< EMECFAN > emecfan
Definition: EMECData.h:137
EMECData::coldcontraction
std::vector< COLDCONTRACTION > coldcontraction
Definition: EMECData.h:136
LArWheelCalculator::m_coldContraction
double m_coldContraction
Definition: LArWheelCalculator.h:199
LArG4::BackInnerBarretteWheelCalib
@ BackInnerBarretteWheelCalib
Definition: LArWheelCalculatorEnums.h:16
LArWheelCalculator::m_HalfGapBetweenWheels
double m_HalfGapBetweenWheels
Definition: LArWheelCalculator.h:160
EMECData::emecmagicnumbers
std::vector< EMECMAGICNUMBERS > emecmagicnumbers
Definition: EMECData.h:135
LArWheelCalculator::m_isBarretteCalib
bool m_isBarretteCalib
Definition: LArWheelCalculator.h:191
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
LArG4::BackOuterBarretteWheelCalib
@ BackOuterBarretteWheelCalib
Definition: LArWheelCalculatorEnums.h:16
LArWheelCalculator::m_steelThickness
double m_steelThickness
Definition: LArWheelCalculator.h:196
LArG4::BackOuterBarretteWheel
@ BackOuterBarretteWheel
Definition: LArWheelCalculatorEnums.h:15
m_type
TokenType m_type
the type
Definition: TProperty.cxx:44
EMECData::emecparams
std::vector< EMECPARAMS > emecparams
Definition: EMECData.h:133
EMECData::emecgeometry
std::vector< EMECGEOMETRY > emecgeometry
Definition: EMECData.h:132
LArWheelCalculator::GetWheelInnerRadius
double GetWheelInnerRadius(std::array< double, 2 > &rInner) const
Definition: LArWheelCalculator.cxx:493
LArWheelCalculator::m_isElectrode
bool m_isElectrode
Definition: LArWheelCalculator.h:188
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
LArWheelCalculator::m_ZeroFanPhi_ForDetNeaFan
double m_ZeroFanPhi_ForDetNeaFan
Definition: LArWheelCalculator.h:176
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArWheelCalculator::m_NumberOfWaves
int m_NumberOfWaves
Definition: LArWheelCalculator.h:178
LArG4::OuterGlueWheel
@ OuterGlueWheel
Definition: LArWheelCalculatorEnums.h:19
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
LArWheelCalculator::m_WheelThickness
double m_WheelThickness
Definition: LArWheelCalculator.h:168
FanCalculatorFactory.h
LArWheelCalculator::~LArWheelCalculator
virtual ~LArWheelCalculator()
Definition: LArWheelCalculator.cxx:92
LArG4::InnerElectrodModule
@ InnerElectrodModule
Definition: LArWheelCalculatorEnums.h:14
LArG4::BackInnerBarretteModule
@ BackInnerBarretteModule
Definition: LArWheelCalculatorEnums.h:17
LArG4::BackOuterBarretteModuleCalib
@ BackOuterBarretteModuleCalib
Definition: LArWheelCalculatorEnums.h:18
LArWheelCalculator::fill_sincos_parameterization
void fill_sincos_parameterization()
Definition: sincos_poly.cxx:247
LArWheelCalculator_Impl::DistanceCalculatorFactory::Create
static IDistanceCalculator * Create(const std::string &sagging_opt, LArWheelCalculator *lwc)
Definition: DistanceCalculatorFactory.cxx:14
LArWheelCalculator::m_isBarrette
bool m_isBarrette
Definition: LArWheelCalculator.h:190
LArG4::InnerLeadWheel
@ InnerLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::m_phiRotation
bool m_phiRotation
Definition: LArWheelCalculator.h:150
LArWheelCalculator::GetWheelOuterRadius
void GetWheelOuterRadius(std::array< double, 2 > &rOuter) const
Definition: LArWheelCalculator.cxx:525
LArWheelCalculator::m_StraightStartSection
double m_StraightStartSection
Definition: LArWheelCalculator.h:158
LArWheelCalculator::m_slant_parametrization
std::array< double, 5 > m_slant_parametrization
Definition: LArWheelCalculator.h:152
LArWheelCalculator::m_eta_hi
double m_eta_hi
Definition: LArWheelCalculator.h:165
LArWheelCalculator::m_NumberOfFans
int m_NumberOfFans
Definition: LArWheelCalculator.h:180
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
LArWheelCalculator::m_leadThicknessInner
double m_leadThicknessInner
Definition: LArWheelCalculator.h:194
LArG4::OuterAbsorberModule
@ OuterAbsorberModule
Definition: LArWheelCalculatorEnums.h:13
LArWheelCalculator::m_distanceCalcImpl
LArWheelCalculator_Impl::IDistanceCalculator * m_distanceCalcImpl
Definition: LArWheelCalculator.h:237
LArWheelCalculator::m_HalfWheelThickness
double m_HalfWheelThickness
Definition: LArWheelCalculator.h:169
LArWheelCalculator::m_zWheelRefPoint
double m_zWheelRefPoint
Definition: LArWheelCalculator.h:161
LArWheelCalculator::m_ZeroFanPhi
double m_ZeroFanPhi
Definition: LArWheelCalculator.h:175
LArWheelCalculator::m_FirstFan
int m_FirstFan
Definition: LArWheelCalculator.h:184
LArWheelCalculator::m_FanStepOnPhi
double m_FanStepOnPhi
Definition: LArWheelCalculator.h:177
LArWheelCalculator::m_QuarterWaveLength
double m_QuarterWaveLength
Definition: LArWheelCalculator.h:172
LArWheelCalculator::m_ZeroGapNumber
int m_ZeroGapNumber
Definition: LArWheelCalculator.h:183
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
LArWheelCalculator::m_FanFoldRadius
double m_FanFoldRadius
Definition: LArWheelCalculator.h:174
a
TList * a
Definition: liststreamerinfos.cxx:10
LArWheelCalculator::m_dWRPtoFrontFace
double m_dWRPtoFrontFace
Definition: LArWheelCalculator.h:159
LArWheelCalculator::m_NumberOfHalfWaves
int m_NumberOfHalfWaves
Definition: LArWheelCalculator.h:179
LArWheelCalculator::outer_wheel_init
void outer_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:424
LArWheelCalculator::m_HalfWaveLength
double m_HalfWaveLength
Definition: LArWheelCalculator.h:173
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LArWheelCalculator::m_ActiveLength
double m_ActiveLength
Definition: LArWheelCalculator.h:157
DEBUG
#define DEBUG
Definition: page_access.h:11
LArWheelCalculator::LArWheelCalculator
LArWheelCalculator(const EMECData &emecData, LArG4::LArWheelCalculator_t a_wheelType, int zside=1)
Definition: LArWheelCalculator.cxx:99
EMECData::emecwheelparameters
std::vector< EMECWHEELPARAMETERS > emecwheelparameters
Definition: EMECData.h:134
LArWheelCalculator::m_SaggingOn
bool m_SaggingOn
Definition: LArWheelCalculator.h:149
LArG4::OuterLeadWheel
@ OuterLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::m_LastFan
int m_LastFan
Definition: LArWheelCalculator.h:185
LArWheelCalculator::m_type
LArG4::LArWheelCalculator_t m_type
Definition: LArWheelCalculator.h:146
LArWheelCalculator::m_isInner
bool m_isInner
Definition: LArWheelCalculator.h:189
LArG4::BackInnerBarretteModuleCalib
@ BackInnerBarretteModuleCalib
Definition: LArWheelCalculatorEnums.h:18
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
LArWheelCalculator::m_zWheelBackFace
double m_zWheelBackFace
Definition: LArWheelCalculator.h:170
LArG4::OuterAbsorberWheel
@ OuterAbsorberWheel
Definition: LArWheelCalculatorEnums.h:11
LArG4::BackInnerBarretteWheel
@ BackInnerBarretteWheel
Definition: LArWheelCalculatorEnums.h:15
DistanceCalculatorFactory.h
LArWheelCalculator::m_zShift
double m_zShift
Definition: LArWheelCalculator.h:166
LArG4::InnerElectrodWheel
@ InnerElectrodWheel
Definition: LArWheelCalculatorEnums.h:12
python.compressB64.c
def c
Definition: compressB64.py:93
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
PortableMsgStream.h
LArG4::LArWheelCalculator_t
LArWheelCalculator_t
Definition: LArWheelCalculatorEnums.h:10
LArWheelCalculator.h
LArWheelCalculator::GetFanHalfThickness
double GetFanHalfThickness() const
Definition: LArWheelCalculator.h:99
Generated on Sun Dec 22 2024 21:13:50 for ATLAS Offline Software by   doxygen 1.8.18