ATLAS Offline Software
LArWheelCalculator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2019 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  ISvcLocator* svcLocator = Gaudi::svcLocator();
109  IMessageSvc* msgSvc;
110  StatusCode status = svcLocator->service("MessageSvc", msgSvc);
111  if(status.isFailure()){
112  throw std::runtime_error("LArWheelCalculator constructor: cannot initialze message service");
113  }
114  MsgStream msg(msgSvc, "LArWheelCalculator");
115 #else
116  PortableMsgStream msg("LArWheelCalculator");
117 #endif
118  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
119  << " (type " << LArWheelCalculatorTypeString(m_type)
120  << "):" << endmsg;
121 
122 
123  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
124  << " (type " << LArWheelCalculatorTypeString(m_type)
125  << "):" << endmsg;
126 
127 #ifdef LARWC_DTNF_NEW
128  msg << MSG::VERBOSE << "compiled with new DTNF" << endmsg;
129 #endif
130 
131  // Access source of detector parameters.
132  msg << MSG::VERBOSE
133  << "initializing data members from DB..." << endmsg;
134 
135  m_zWheelRefPoint =emecData.emecgeometry[0].Z0*cm;
136  m_dMechFocaltoWRP =emecData.emecgeometry[0].Z1*cm;
137  m_dElecFocaltoWRP =emecData.emecgeometry[0].DCF*cm;
138  m_HalfGapBetweenWheels =emecData.emecgeometry[0].DCRACK*cm;
139  m_rOuterCutoff =emecData.emecgeometry[0].RLIMIT*cm;
140  m_zShift =emecData.emecgeometry[0].ZSHIFT*cm;
141 
142 
143  m_eta_hi =emecData.emecwheelparameters[0].ETAINT;
144  m_eta_mid =emecData.emecwheelparameters[0].ETAEXT;
145  m_eta_low =emecData.emecwheelparameters[1].ETAEXT;
146 
147 
148 
149  m_leadThicknessInner=emecData.emecfan[0].LEADTHICKNESSINNER*mm;
150  m_leadThicknessOuter=emecData.emecfan[0].LEADTHICKNESSOUTER*mm;
151  m_steelThickness=emecData.emecfan[0].STEELTHICKNESS*mm;
152  m_glueThickness=emecData.emecfan[0].GLUETHICKNESS*mm;
153  m_electrodeTotalThickness=emecData.emecfan[0].ELECTRODETOTALTHICKNESS*mm;
154  m_coldContraction=emecData.coldcontraction[0].ABSORBERCONTRACTION;
155  m_electrodeInvContraction=emecData.coldcontraction[0].ELECTRODEINVCONTRACTION;
156 
157 
158 
159  m_ActiveLength =emecData.emecmagicnumbers[0].ACTIVELENGTH*mm;
160  m_StraightStartSection =emecData.emecmagicnumbers[0].STRAIGHTSTARTSECTION*mm;
161  m_dWRPtoFrontFace =emecData.emecmagicnumbers[0].REFTOACTIVE*mm;
162 
163 
164  m_WheelThickness = m_ActiveLength + 2.*m_StraightStartSection;
165  m_HalfWheelThickness = m_WheelThickness * 0.5;
166 
167  std::string pr_opt_value=emecData.emecparams[0].PHIROTATION;
168  std::string sagging_opt_value=emecData.emecparams[0].SAGGING;
169 
170  m_phiRotation = pr_opt_value == "g3"? true: false;
171 
172  m_zWheelFrontFace = m_dMechFocaltoWRP + m_dWRPtoFrontFace;
173  m_zWheelBackFace = m_zWheelFrontFace + m_WheelThickness;
174 
175  msg << MSG::DEBUG << "... got these values:" << endmsg
176  << "m_zWheelRefPoint : " << m_zWheelRefPoint / cm << " [cm]" << endmsg
177  << "m_dMechFocaltoWRP : " << m_dMechFocaltoWRP / cm << " [cm]" << endmsg
178  << "m_dElecFocaltoWRP : " << m_dElecFocaltoWRP / cm << " [cm]" << endmsg
179  << "m_HalfGapBetweenWheels : " << m_HalfGapBetweenWheels / cm << " [cm]" << endmsg
180  << "m_rOuterCutoff : " << m_rOuterCutoff / cm << " [cm]" << endmsg
181  << "m_zWheelFrontFace : " << m_zWheelFrontFace / cm << " [cm]" << endmsg
182  << "m_zWheelBackFace : " << m_zWheelBackFace / cm << " [cm]" << endmsg
183  << "m_zShift : " << m_zShift / cm << " [cm]" << endmsg
184  << "Phi rotation : " << (m_phiRotation? "true": "false") << "" << endmsg
185  << "eta wheels limits : " << m_eta_low << ", " << m_eta_mid << ", " << m_eta_hi
186  << endmsg;
187  msg << MSG::VERBOSE << "hardcoded constants: " << endmsg
188  << "m_WheelThickness : " << m_WheelThickness / cm << " [cm]" << endmsg
189  << "m_dWRPtoFrontFace : " << m_dWRPtoFrontFace / cm << " [cm]"
190  << endmsg;
191 
192 
193  // Constructor initializes the geometry.
194 
195  m_isBarrette = false;
196  m_isBarretteCalib = false;
197  m_isModule = false;
198  m_isElectrode = false;
199  m_isInner = false;
200  m_FirstFan = 0;
201  m_LastFan = 0;
202 
203  switch(m_type){
204  case LArG4::BackInnerBarretteWheelCalib:
205  m_isBarretteCalib = true;
206  /* FALLTHROUGH */
207  case LArG4::BackInnerBarretteWheel:
208  m_isBarrette = true;
209  m_type = LArG4::InnerAbsorberWheel;
210  /* FALLTHROUGH */
211  case LArG4::InnerAbsorberWheel:
212  case LArG4::InnerGlueWheel:
213  case LArG4::InnerLeadWheel:
214  inner_wheel_init(emecData);
215  m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
216  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
217  break;
218  case LArG4::BackOuterBarretteWheelCalib:
219  m_isBarretteCalib = true;
220  /* FALLTHROUGH */
221  case LArG4::BackOuterBarretteWheel:
222  m_isBarrette = true;
223  m_type = LArG4::OuterAbsorberWheel;
224  /* FALLTHROUGH */
225  case LArG4::OuterAbsorberWheel:
226  case LArG4::OuterGlueWheel:
227  case LArG4::OuterLeadWheel:
228  outer_wheel_init(emecData);
229  m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
230  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
231  break;
232  case LArG4::InnerElectrodWheel:
233  inner_wheel_init(emecData);
234  m_ZeroFanPhi = 0;
235  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
236  m_isElectrode = true;
237  break;
238  case LArG4::OuterElectrodWheel:
239  outer_wheel_init(emecData);
240  m_ZeroFanPhi = 0;
241  if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
242  m_isElectrode = true;
243  break;
244  case LArG4::BackInnerBarretteModuleCalib:
245  m_isBarretteCalib = true;
246  /* FALLTHROUGH */
247  case LArG4::BackInnerBarretteModule:
248  m_isBarrette = true;
249  m_type = LArG4::InnerAbsorberModule;
250  /* FALLTHROUGH */
251  case LArG4::InnerAbsorberModule:
252  inner_wheel_init(emecData);
253  module_init();
254  m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
255  // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
256  break;
257  case LArG4::BackOuterBarretteModuleCalib:
258  m_isBarretteCalib = true;
259  /* FALLTHROUGH */
260  case LArG4::BackOuterBarretteModule:
261  m_isBarrette = true;
262  m_type = LArG4::OuterAbsorberModule;
263  /* FALLTHROUGH */
264  case LArG4::OuterAbsorberModule:
265  outer_wheel_init(emecData);
266  module_init();
267  m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
268  // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
269  break;
270  case LArG4::InnerElectrodModule:
271  inner_wheel_init(emecData);
272  module_init();
273  m_FirstFan ++;
274  m_isElectrode = true;
275  break;
276  case LArG4::OuterElectrodModule:
277  outer_wheel_init(emecData);
278  module_init();
279  m_FirstFan ++;
280  m_isElectrode = true;
281  break;
282  default:
283  throw std::runtime_error("LArWheelCalculator constructor:unknown LArWheelCalculator_t");
284  }
285  m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
286  m_NumberOfHalfWaves = m_NumberOfWaves * 2;
287  m_HalfWaveLength = m_ActiveLength / m_NumberOfHalfWaves;
288  m_QuarterWaveLength = m_HalfWaveLength * 0.5;
289  //m_HalfNumberOfFans = m_NumberOfFans / 2;
290  m_FanHalfThickness = GetFanHalfThickness(m_type);
291 
292  // Init sagging
293  // value read above
294  // std::string sagging_opt_value = (*DB_EMECParams)[0]->getString("SAGGING");
295 
296  msg << MSG::VERBOSE << "SAGGING value = " << sagging_opt_value << endmsg;
297 
298  // the same condition is in DistanceCalculatorFactory::Create
299  m_SaggingOn = (sagging_opt_value != "" && sagging_opt_value != "off")? true: false;
300 
301  m_distanceCalcImpl = LArWheelCalculator_Impl::DistanceCalculatorFactory::Create(
302  sagging_opt_value, this);
303  if (m_SaggingOn) {
304  msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOn = " << this
305  << ',' << m_distanceCalcImpl << endmsg;
306  } else {
307  msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOff = " << this
308  << ',' << m_distanceCalcImpl << endmsg;
309  }
310 
311  m_fanCalcImpl = LArWheelCalculator_Impl::FanCalculatorFactory::Create(
312  m_SaggingOn, m_isModule, this);
313 
314  //--------------------------
315  // At this place there was the loading of sagging parameters
316  // Transfered to DistanceCalculatorSaggingOn
317  //--------------------------
318 
319  // Get option: Slant params.
320  msg << MSG::VERBOSE << "Loading SlantAngle parameters ...";
321  std::string slant_params;
322 
323  if (m_isInner) {
324  slant_params=emecData.emecparams[0].INNERSLANTPARAM;
325  } else {
326  slant_params=emecData.emecparams[0].OUTERSLANTPARAM;
327  }
328 
329  msg << (m_isInner?" InnerWheel ":" OuterWheel ") << slant_params << endmsg;
330 
331  if(slant_params != "" && slant_params != "default"){
332  double a, b, c, d, e;
333  if(sscanf(slant_params.c_str(), "%80le %80le %80le %80le %80le", &a, &b, &c, &d, &e) != 5){
334  msg << MSG::ERROR
335  << "LArWheelCalculator: ERROR: wrong value(s) "
336  << "for EMEC slant angle parameters: "
337  << slant_params << ", "
338  << "defaults are used" << endmsg;
339  } else {
340  m_slant_parametrization[0] = a;
341  m_slant_parametrization[1] = b;
342  m_slant_parametrization[2] = c;
343  m_slant_parametrization[3] = d;
344  m_slant_parametrization[4] = e;
345  m_slant_use_default = false;
346  }
347  } // else already initialized in inner/outer_wheel_init()
348 
349  fill_sincos_parameterization(); // initialize sin&cos parameterization
350 
351  msg << MSG::VERBOSE << "All params initialized. Print some internal variables" << endmsg;
352 
353  msg << MSG::VERBOSE << "Data members:" << endmsg
354  << "m_AtlasZside = " << m_AtlasZside << "" << endmsg
355  << "m_NumberOfFans = " << m_NumberOfFans << "" << endmsg
356  << "m_ZeroFanPhi = " << m_ZeroFanPhi << "" << endmsg
357  << "m_ZeroFanPhi_ForDetNeaFan = " << m_ZeroFanPhi_ForDetNeaFan << "" << endmsg
358  << "m_FanStepOnPhi = " << m_FanStepOnPhi << "" << endmsg
359  << "m_FanHalfThickness = " << m_FanHalfThickness << "" << endmsg
360  //<< "Sagging parameters : " << m_sagging_parameter[0][0] << " " << m_sagging_parameter[0][1] << "" << endmsg
361  //<< "Sagging parameters : " << m_sagging_parameter[1][0] << " " << m_sagging_parameter[1][1] << "" << endmsg
362  << "slant_params = " << slant_params << "" << endmsg
363  << "Sagging option = " << sagging_opt_value << "" << endmsg
364  << "SaggingOn = " << (m_SaggingOn? "true": "false") << "" << endmsg
365  << "Slant parameters : ";
366  for(int i = 0; i < 5; i ++) msg << " " << m_slant_parametrization[i];
367  msg << endmsg;
368 
369  if(m_isModule){
370  msg << MSG::VERBOSE
371  << "module_init: FirstFan = " << m_FirstFan
372  << ", LastFan = " << m_LastFan
373  << ", ZeroFanPhi = " << m_ZeroFanPhi
374  << endmsg;
375  }
376 
377  //m_fan_number = -1000;
378 
379  // Is the following code fragment obsoleted? DM 2015-03-13
380  /* to compare various methods of slant angle computation:
381  if(isInner) return;
382  FILE *O = fopen("slant_stat.table1.txt", "w");
383  if(O == 0) abort();
384  struct timeval t1, t2;
385  struct timezone tz;
386  std::vector<double> alpha;
387  gettimeofday(&t1, &tz);
388  for(double r = 600.; r < 2100.; r += .01){
389  alpha.push_back(parameterized_slant_angle(r));
390  }
391  gettimeofday(&t2, &tz);
392 
393  fprintf(O, "%d.%06d %d.%06d" << endmsg, t1.tv_sec, t1.tv_usec, t2.tv_sec, t2.tv_usec);
394  int i = 0;
395  for(double r = 600.; r < 2100.; r += .01, i ++){
396  fprintf(O, "%f %f\n", r, alpha[i]);
397  }
398 
399  fclose(O);
400  exit(0);
401  */
402 }
403 
404 /* converts module gap number into wheel gap number */
405 int LArWheelCalculator::PhiGapNumberForWheel(int i) const
406 {
407  return m_fanCalcImpl->PhiGapNumberForWheel(i);
408 }
409 
410 void LArWheelCalculator::inner_wheel_init(const EMECData & emecData)
411 {
412  for(int i = 0; i < 5; ++ i) {
413  m_slant_parametrization[i] = default_slant_parametrization[0][i];
414  }
415  m_slant_use_default = true;
416 
417  m_NumberOfFans=emecData.emecwheelparameters[0].NABS;
418  m_NumberOfWaves=emecData.emecwheelparameters[0].NACC;
419 
420  m_FanFoldRadius = 3.25*mm;
421  m_ZeroGapNumber = 64; // internal constant, should not be taken from DB
422  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
423  m_isInner = true;
424 }
425 
426 void LArWheelCalculator::outer_wheel_init(const EMECData & emecData)
427 {
428  for(int i = 0; i < 5; ++ i) {
429  m_slant_parametrization[i] = default_slant_parametrization[1][i];
430  }
431  m_slant_use_default = true;
432 
433  m_NumberOfFans=emecData.emecwheelparameters[1].NABS;
434  m_NumberOfWaves=emecData.emecwheelparameters[1].NACC;
435 
436 
437  m_FanFoldRadius = 3.0*mm;
438  m_ZeroGapNumber = 192; // internal constant, should not be taken from DB
439  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
440  m_isInner = false;
441 }
442 
443 double LArWheelCalculator::GetFanHalfThickness(LArG4::LArWheelCalculator_t t) const
444 {
445 
446  switch(t){
447  case LArG4::BackInnerBarretteWheelCalib:
448  case LArG4::BackInnerBarretteModuleCalib:
449  case LArG4::BackInnerBarretteWheel:
450  case LArG4::BackInnerBarretteModule:
451  case LArG4::InnerAbsorberWheel:
452  case LArG4::InnerAbsorberModule:
453  return (m_leadThicknessInner / 2 + m_steelThickness + m_glueThickness)*m_coldContraction; // new values, 02.11.06 J.T. with contraction in cold
454  // lead / 2 + steel + glue
455  case LArG4::InnerGlueWheel:
456  return (m_leadThicknessInner / 2 + m_glueThickness)*m_coldContraction;
457  case LArG4::InnerLeadWheel:
458  return m_leadThicknessInner / 2 * m_coldContraction;
459 
460  case LArG4::BackOuterBarretteWheelCalib:
461  case LArG4::BackOuterBarretteModuleCalib:
462  case LArG4::BackOuterBarretteWheel:
463  case LArG4::BackOuterBarretteModule:
464  case LArG4::OuterAbsorberWheel:
465  case LArG4::OuterAbsorberModule:
466  return (m_leadThicknessOuter / 2 + m_steelThickness + m_glueThickness)*m_coldContraction; // new values, 02.11.06 J.T.
467  case LArG4::OuterGlueWheel:
468  return (m_leadThicknessOuter / 2 + m_glueThickness)*m_coldContraction;
469  case LArG4::OuterLeadWheel:
470  return m_leadThicknessOuter / 2 * m_coldContraction;
471 
472  case LArG4::InnerElectrodWheel:
473  case LArG4::OuterElectrodWheel:
474  case LArG4::InnerElectrodModule:
475  case LArG4::OuterElectrodModule:
476  return m_electrodeTotalThickness/m_electrodeInvContraction * 0.5; //new values, 02.11.06 J.T
477  }
478  throw std::runtime_error("LArWheelCalculator::GetFanHalfThickness: wrong wheel type");
479 }
480 
481 void LArWheelCalculator::module_init()
482 {
483  m_isModule = true;
484  m_LastFan = m_NumberOfFans / 8;
485  m_FirstFan = 0;
486  m_ZeroFanPhi = - m_LastFan / 2 * m_FanStepOnPhi;
487 }
488 
489 /*
490  array of r is filled with:
491  for inner wheel - 2 elements { r_front, r_back }
492  for outer wheel - 3 elements { r_front, r_middle, r_back }
493  return value - delta_z of middle point in case of outer wheel
494 */
495 double LArWheelCalculator::GetWheelInnerRadius(double *r) const
496 {
497  double zMid = 0.;
498  if(m_isInner){
499  double tanThetaInner = 2. * exp(-m_eta_hi ) / (1. - exp(-2.*m_eta_hi ));
500  r[0] = m_zWheelFrontFace * tanThetaInner;
501  r[1] = m_zWheelBackFace * tanThetaInner;
502  } else {
503  double tanThetaMid = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
504  double inv_tanThetaOuter = (1. - exp(-2.*m_eta_low)) / (2. * exp(-m_eta_low));
505  // Note that there is a 3mm gap between the outer surface of the
506  // inner wheel and the inner surface of the outer wheel.
507  r[0] = m_zWheelFrontFace * tanThetaMid + m_HalfGapBetweenWheels;
508  r[1] = m_rOuterCutoff * inv_tanThetaOuter * tanThetaMid + m_HalfGapBetweenWheels;
509  r[2] = m_zWheelBackFace * tanThetaMid + m_HalfGapBetweenWheels;
510  zMid = m_rOuterCutoff * inv_tanThetaOuter - m_zWheelFrontFace;
511  }
512  return zMid;
513 }
514 
515 /*
516  array of r is filled with:
517  for inner wheel - 2 elements { r_front, r_back }
518  for outer wheel - 3 elements { r_front, r_middle, r_back }
519 */
520 void LArWheelCalculator::GetWheelOuterRadius(double *r) const
521 {
522  if(m_isInner){
523  double tanThetaMid = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
524  // Note that there is a 3mm gap between the outer surface of the
525  // inner wheel and the inner surface of the outer wheel.
526  r[0] = m_zWheelFrontFace * tanThetaMid - m_HalfGapBetweenWheels;
527  r[1] = m_zWheelBackFace * tanThetaMid - m_HalfGapBetweenWheels;
528  } else {
529  double tanThetaOuter = 2. * exp(-m_eta_low) / (1. - exp(-2.*m_eta_low));
530  r[0] = m_zWheelFrontFace * tanThetaOuter;
531  r[1] = m_rOuterCutoff;
532  r[2] = m_rOuterCutoff;
533  }
534 }
LArWheelCalculator::m_dMechFocaltoWRP
double m_dMechFocaltoWRP
Definition: LArWheelCalculator.h:158
beamspotman.r
def r
Definition: beamspotman.py:676
LArWheelCalculator::m_rOuterCutoff
double m_rOuterCutoff
Definition: LArWheelCalculator.h:160
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:194
LArWheelCalculator::module_init
void module_init()
Definition: LArWheelCalculator.cxx:481
LArWheelCalculator::m_eta_low
double m_eta_low
Definition: LArWheelCalculator.h:161
LArWheelCalculator_Impl::IFanCalculator::PhiGapNumberForWheel
virtual int PhiGapNumberForWheel(int i) const =0
LArWheelCalculator::m_glueThickness
double m_glueThickness
Definition: LArWheelCalculator.h:193
EMECData.h
LArWheelCalculator::m_isModule
bool m_isModule
Definition: LArWheelCalculator.h:183
LArG4::InnerAbsorberWheel
@ InnerAbsorberWheel
Definition: LArWheelCalculatorEnums.h:11
LArWheelCalculator::m_slant_use_default
bool m_slant_use_default
Definition: LArWheelCalculator.h:147
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:159
LArWheelCalculator::m_electrodeInvContraction
double m_electrodeInvContraction
Definition: LArWheelCalculator.h:196
LArWheelCalculator::m_eta_mid
double m_eta_mid
Definition: LArWheelCalculator.h:161
EMECData
Definition: EMECData.h:131
LArWheelCalculator::inner_wheel_init
void inner_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:410
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:405
LArWheelCalculator::m_FanHalfThickness
double m_FanHalfThickness
Definition: LArWheelCalculator.h:178
LArG4::InnerAbsorberModule
@ InnerAbsorberModule
Definition: LArWheelCalculatorEnums.h:13
LArWheelCalculator::m_fanCalcImpl
LArWheelCalculator_Impl::IFanCalculator * m_fanCalcImpl
Definition: LArWheelCalculator.h:234
LArG4::OuterElectrodModule
@ OuterElectrodModule
Definition: LArWheelCalculatorEnums.h:14
LArWheelCalculator::m_leadThicknessOuter
double m_leadThicknessOuter
Definition: LArWheelCalculator.h:191
LArWheelCalculator::m_AtlasZside
int m_AtlasZside
Definition: LArWheelCalculator.h:144
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:166
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:195
LArG4::BackInnerBarretteWheelCalib
@ BackInnerBarretteWheelCalib
Definition: LArWheelCalculatorEnums.h:16
LArWheelCalculator::m_HalfGapBetweenWheels
double m_HalfGapBetweenWheels
Definition: LArWheelCalculator.h:156
EMECData::emecmagicnumbers
std::vector< EMECMAGICNUMBERS > emecmagicnumbers
Definition: EMECData.h:135
LArWheelCalculator::m_isBarretteCalib
bool m_isBarretteCalib
Definition: LArWheelCalculator.h:187
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:192
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::m_isElectrode
bool m_isElectrode
Definition: LArWheelCalculator.h:184
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
LArWheelCalculator::m_ZeroFanPhi_ForDetNeaFan
double m_ZeroFanPhi_ForDetNeaFan
Definition: LArWheelCalculator.h:172
lumiFormat.i
int i
Definition: lumiFormat.py:92
LArWheelCalculator::m_NumberOfWaves
int m_NumberOfWaves
Definition: LArWheelCalculator.h:174
LArG4::OuterGlueWheel
@ OuterGlueWheel
Definition: LArWheelCalculatorEnums.h:19
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArWheelCalculator::m_WheelThickness
double m_WheelThickness
Definition: LArWheelCalculator.h:164
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::GetWheelOuterRadius
void GetWheelOuterRadius(double *) const
Definition: LArWheelCalculator.cxx:520
LArWheelCalculator::m_isBarrette
bool m_isBarrette
Definition: LArWheelCalculator.h:186
LArG4::InnerLeadWheel
@ InnerLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::m_phiRotation
bool m_phiRotation
Definition: LArWheelCalculator.h:146
LArWheelCalculator::GetWheelInnerRadius
double GetWheelInnerRadius(double *) const
Definition: LArWheelCalculator.cxx:495
LArWheelCalculator::m_StraightStartSection
double m_StraightStartSection
Definition: LArWheelCalculator.h:154
LArWheelCalculator::m_slant_parametrization
std::array< double, 5 > m_slant_parametrization
Definition: LArWheelCalculator.h:148
LArWheelCalculator::m_eta_hi
double m_eta_hi
Definition: LArWheelCalculator.h:161
LArWheelCalculator::m_NumberOfFans
int m_NumberOfFans
Definition: LArWheelCalculator.h:176
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
LArWheelCalculator::m_leadThicknessInner
double m_leadThicknessInner
Definition: LArWheelCalculator.h:190
LArG4::OuterAbsorberModule
@ OuterAbsorberModule
Definition: LArWheelCalculatorEnums.h:13
LArWheelCalculator::m_distanceCalcImpl
LArWheelCalculator_Impl::IDistanceCalculator * m_distanceCalcImpl
Definition: LArWheelCalculator.h:233
LArWheelCalculator::m_HalfWheelThickness
double m_HalfWheelThickness
Definition: LArWheelCalculator.h:165
LArWheelCalculator::m_zWheelRefPoint
double m_zWheelRefPoint
Definition: LArWheelCalculator.h:157
LArWheelCalculator::m_ZeroFanPhi
double m_ZeroFanPhi
Definition: LArWheelCalculator.h:171
LArWheelCalculator::m_FirstFan
int m_FirstFan
Definition: LArWheelCalculator.h:180
LArWheelCalculator::m_FanStepOnPhi
double m_FanStepOnPhi
Definition: LArWheelCalculator.h:173
LArWheelCalculator::m_QuarterWaveLength
double m_QuarterWaveLength
Definition: LArWheelCalculator.h:168
LArWheelCalculator::m_ZeroGapNumber
int m_ZeroGapNumber
Definition: LArWheelCalculator.h:179
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
LArWheelCalculator::m_FanFoldRadius
double m_FanFoldRadius
Definition: LArWheelCalculator.h:170
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
LArWheelCalculator::m_dWRPtoFrontFace
double m_dWRPtoFrontFace
Definition: LArWheelCalculator.h:155
LArWheelCalculator::m_NumberOfHalfWaves
int m_NumberOfHalfWaves
Definition: LArWheelCalculator.h:175
LArWheelCalculator::outer_wheel_init
void outer_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:426
LArWheelCalculator::m_HalfWaveLength
double m_HalfWaveLength
Definition: LArWheelCalculator.h:169
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LArWheelCalculator::m_ActiveLength
double m_ActiveLength
Definition: LArWheelCalculator.h:153
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:145
LArG4::OuterLeadWheel
@ OuterLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::m_LastFan
int m_LastFan
Definition: LArWheelCalculator.h:181
merge.status
status
Definition: merge.py:17
LArWheelCalculator::m_type
LArG4::LArWheelCalculator_t m_type
Definition: LArWheelCalculator.h:142
LArWheelCalculator::m_isInner
bool m_isInner
Definition: LArWheelCalculator.h:185
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:166
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:162
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:97
Generated on Tue Jul 2 2024 21:20:43 for ATLAS Offline Software by   doxygen 1.8.18