ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
LArWheelCalculator Class Reference

#include <LArWheelCalculator.h>

Collaboration diagram for LArWheelCalculator:

Public Member Functions

 LArWheelCalculator (const EMECData &emecData, LArG4::LArWheelCalculator_t a_wheelType, int zside=1)
 
virtual ~LArWheelCalculator ()
 
 LArWheelCalculator (const LArWheelCalculator &)=delete
 
LArWheelCalculator & operator= (const LArWheelCalculator &)=delete
 
double GetFanHalfThickness (LArG4::LArWheelCalculator_t) const
 
double GetWheelThickness () const
 
double GetdWRPtoFrontFace () const
 
double GetStraightStartSection () const
 
virtual LArG4::LArWheelCalculator_t type () const
 
int GetAtlasZside () const
 
double zShift () const
 
double GetFanFoldRadius () const
 
double GetZeroFanPhi () const
 
int GetNumberOfWaves () const
 
int GetNumberOfHalfWaves () const
 
int GetNumberOfFans () const
 
double GetActiveLength () const
 
double GetFanStepOnPhi () const
 
double GetHalfWaveLength () const
 
double GetQuarterWaveLength () const
 
double GetWheelRefPoint () const
 
double GetFanHalfThickness () const
 
bool GetisModule () const
 
bool GetisElectrode () const
 
bool GetisInner () const
 
bool GetisBarrette () const
 
bool GetisBarretteCalib () const
 
double GetWheelInnerRadius (std::array< double, 2 > &rInner) const
 
double GetWheelInnerRadius (std::array< double, 3 > &rInner) const
 
void GetWheelOuterRadius (std::array< double, 2 > &rOuter) const
 
void GetWheelOuterRadius (std::array< double, 3 > &rOuter) const
 
double GetElecFocaltoWRP () const
 
int GetFirstFan () const
 
int GetLastFan () const
 
int GetStartGapNumber () const
 
void SetStartGapNumber (int n)
 
int adjust_fan_number (int fan_number) const
 
double parameterized_slant_angle (double) const
 Calculates wave slant angle using parametrization for current wheel for given distance from calorimeter axis. More...
 
geometry methods
double DistanceToTheNearestFan (CLHEP::Hep3Vector &p, int &out_fan_number) const
 Determines the nearest to the input point fan. More...
 
double DistanceToTheNeutralFibre (const CLHEP::Hep3Vector &p, int fan_number) const
 Calculates aproximate, probably underestimate, distance to the neutral fibre of the vertical fan. More...
 
CLHEP::Hep3Vector NearestPointOnNeutralFibre (const CLHEP::Hep3Vector &p, int fan_number) const
 
std::vector< double > NearestPointOnNeutralFibre_asVector (const CLHEP::Hep3Vector &p, int fan_number) const
 
int GetPhiGap (const CLHEP::Hep3Vector &p) const
 
int PhiGapNumberForWheel (int) const
 
std::pair< int, int > GetPhiGapAndSide (const CLHEP::Hep3Vector &p) const
 
double AmplitudeOfSurface (const CLHEP::Hep3Vector &P, int side, int fan_number) const
 

Static Public Member Functions

static const char * LArWheelCalculatorTypeString (LArG4::LArWheelCalculator_t)
 

Private Member Functions

void outer_wheel_init (const EMECData &)
 
void inner_wheel_init (const EMECData &)
 
void module_init ()
 
void parameterized_sincos (const double, double &, double &) const
 
void parameterized_sin (const double, double &, double &) const
 
void fill_sincos_parameterization ()
 

Private Attributes

LArG4::LArWheelCalculator_t m_type
 
int m_AtlasZside
 
bool m_SaggingOn
 
bool m_phiRotation
 
bool m_slant_use_default
 
std::array< double, 5 > m_slant_parametrization
 
std::array< double, LARWC_SINCOS_POLY+1 > m_sin_parametrization
 
std::array< double, LARWC_SINCOS_POLY+1 > m_cos_parametrization
 
std::vector< std::vector< double > > m_sagging_parameter
 
double m_ActiveLength
 
double m_StraightStartSection
 
double m_dWRPtoFrontFace
 
double m_HalfGapBetweenWheels
 
double m_zWheelRefPoint
 
double m_dMechFocaltoWRP
 
double m_dElecFocaltoWRP
 
double m_rOuterCutoff
 
double m_eta_hi
 
double m_eta_mid
 
double m_eta_low
 
double m_zShift
 
double m_WheelThickness
 
double m_HalfWheelThickness
 
double m_zWheelFrontFace
 
double m_zWheelBackFace
 
double m_QuarterWaveLength
 
double m_HalfWaveLength
 
double m_FanFoldRadius
 
double m_ZeroFanPhi
 
double m_ZeroFanPhi_ForDetNeaFan
 
double m_FanStepOnPhi
 
int m_NumberOfWaves
 
int m_NumberOfHalfWaves
 
int m_NumberOfFans
 
double m_FanHalfThickness
 
int m_ZeroGapNumber
 
int m_FirstFan
 
int m_LastFan
 
bool m_isModule
 
bool m_isElectrode
 
bool m_isInner
 
bool m_isBarrette
 
bool m_isBarretteCalib
 
double m_leadThicknessInner
 
double m_leadThicknessOuter
 
double m_steelThickness
 
double m_glueThickness
 
double m_electrodeTotalThickness
 
double m_coldContraction
 
double m_electrodeInvContraction
 
LArWheelCalculator_Impl::IDistanceCalculator * m_distanceCalcImpl
 
LArWheelCalculator_Impl::IFanCalculator * m_fanCalcImpl
 

Friends

class LArWheelCalculator_Impl::DistanceCalculatorSaggingOff
 
class LArWheelCalculator_Impl::DistanceCalculatorSaggingOn
 
class LArWheelCalculator_Impl::ModuleFanCalculator
 
template<typename SaggingType >
class LArWheelCalculator_Impl::WheelFanCalculator
 
template<typename SaggingType >
class LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan
 

Detailed Description

This class separates some of the geometry details of the LAr endcap. 26-May-2009 AMS: remove all previous comments from here as obsoleted

Definition at line 59 of file LArWheelCalculator.h.

Constructor & Destructor Documentation

◆ LArWheelCalculator() [1/2]

LArWheelCalculator::LArWheelCalculator ( const EMECData &  emecData,
LArG4::LArWheelCalculator_t  a_wheelType,
int  zside = 1 
)

Definition at line 99 of file LArWheelCalculator.cxx.

99  :
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 }

◆ ~LArWheelCalculator()

LArWheelCalculator::~LArWheelCalculator ( )
virtual

Definition at line 92 of file LArWheelCalculator.cxx.

92  {
93  delete m_distanceCalcImpl;
94  m_distanceCalcImpl = 0;
95  delete m_fanCalcImpl;
96  m_fanCalcImpl = 0;
97 }

◆ LArWheelCalculator() [2/2]

LArWheelCalculator::LArWheelCalculator ( const LArWheelCalculator &  )
delete

Member Function Documentation

◆ adjust_fan_number()

int LArWheelCalculator::adjust_fan_number ( int  fan_number) const
inline

Definition at line 218 of file LArWheelCalculator.h.

218  {
219  int res_fan_number = fan_number;
220  if(res_fan_number < 0) res_fan_number += m_NumberOfFans;
221  res_fan_number += m_ZeroGapNumber;
222  if(res_fan_number >= m_NumberOfFans) res_fan_number -= m_NumberOfFans;
223  return res_fan_number;
224  }

◆ AmplitudeOfSurface()

double LArWheelCalculator::AmplitudeOfSurface ( const CLHEP::Hep3Vector &  P,
int  side,
int  fan_number 
) const

Definition at line 130 of file LArWheelCalculatorGeometry.cxx.

131 {
132  return m_distanceCalcImpl->AmplitudeOfSurface(P, side, fan_number);
133 }

◆ DistanceToTheNearestFan()

double LArWheelCalculator::DistanceToTheNearestFan ( CLHEP::Hep3Vector &  p,
int &  out_fan_number 
) const

Determines the nearest to the input point fan.

Rotates point p to the localFan coordinates and returns the fan number to out_fan_number parameter.

Definition at line 90 of file LArWheelCalculatorGeometry.cxx.

91 {
92  return m_fanCalcImpl->DistanceToTheNearestFan(p, out_fan_number);
93 }

◆ DistanceToTheNeutralFibre()

double LArWheelCalculator::DistanceToTheNeutralFibre ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const

Calculates aproximate, probably underestimate, distance to the neutral fibre of the vertical fan.

Sign of return value means side of the fan; negative - lower phi.

Definition at line 108 of file LArWheelCalculatorGeometry.cxx.

109 {
110  return m_distanceCalcImpl->DistanceToTheNeutralFibre(P, fan_number);
111 }

◆ fill_sincos_parameterization()

void LArWheelCalculator::fill_sincos_parameterization ( )
private

Definition at line 247 of file sincos_poly.cxx.

248 {
249  // The polynomial approximations are calculated once per side, and stored
250  // as statics for reuse in successive calculator instances.
251  const sincos_params& p = m_isInner ? inner_params(*this) : outer_params(*this);
252 
253  // Fill the parameters into our instances variables
254  m_sin_parametrization = p.sin;
255  m_cos_parametrization = p.cos;
256 
257  // Parameterization for the vectorized sincos calculation
258  // see ATLASSIM-4753 for details
259  // s4, s5, c4, c5
260  // s2, s3, c2, c3
261  // s0, s1, c0, c1
262  m_vsincos_par.param_0[0] = m_sin_parametrization[4];
263  m_vsincos_par.param_0[1] = m_sin_parametrization[5];
264  m_vsincos_par.param_0[2] = m_cos_parametrization[4];
265  m_vsincos_par.param_0[3] = m_cos_parametrization[5];
266  m_vsincos_par.param_1[0] = m_sin_parametrization[2];
267  m_vsincos_par.param_1[1] = m_sin_parametrization[3];
268  m_vsincos_par.param_1[2] = m_cos_parametrization[2];
269  m_vsincos_par.param_1[3] = m_cos_parametrization[3];
270  m_vsincos_par.param_2[0] = m_sin_parametrization[0];
271  m_vsincos_par.param_2[1] = m_sin_parametrization[1];
272  m_vsincos_par.param_2[2] = m_cos_parametrization[0];
273  m_vsincos_par.param_2[3] = m_cos_parametrization[1];
274 }

◆ GetActiveLength()

double LArWheelCalculator::GetActiveLength ( ) const
inline

Definition at line 94 of file LArWheelCalculator.h.

94 { return m_ActiveLength; }

◆ GetAtlasZside()

int LArWheelCalculator::GetAtlasZside ( ) const
inline

Definition at line 86 of file LArWheelCalculator.h.

86 { return m_AtlasZside; }

◆ GetdWRPtoFrontFace()

double LArWheelCalculator::GetdWRPtoFrontFace ( ) const
inline

Definition at line 81 of file LArWheelCalculator.h.

81 { return m_dWRPtoFrontFace; }

◆ GetElecFocaltoWRP()

double LArWheelCalculator::GetElecFocaltoWRP ( ) const
inline

Definition at line 112 of file LArWheelCalculator.h.

112 { return m_dElecFocaltoWRP; }

◆ GetFanFoldRadius()

double LArWheelCalculator::GetFanFoldRadius ( ) const
inline

Definition at line 88 of file LArWheelCalculator.h.

88 { return m_FanFoldRadius; }

◆ GetFanHalfThickness() [1/2]

double LArWheelCalculator::GetFanHalfThickness ( ) const
inline

Definition at line 99 of file LArWheelCalculator.h.

99 { return m_FanHalfThickness; }

◆ GetFanHalfThickness() [2/2]

double LArWheelCalculator::GetFanHalfThickness ( LArG4::LArWheelCalculator_t  t) const

Definition at line 441 of file LArWheelCalculator.cxx.

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 }

◆ GetFanStepOnPhi()

double LArWheelCalculator::GetFanStepOnPhi ( ) const
inline

Definition at line 95 of file LArWheelCalculator.h.

95 { return m_FanStepOnPhi; }

◆ GetFirstFan()

int LArWheelCalculator::GetFirstFan ( ) const
inline

Definition at line 115 of file LArWheelCalculator.h.

115 { return m_FirstFan; }

◆ GetHalfWaveLength()

double LArWheelCalculator::GetHalfWaveLength ( ) const
inline

Definition at line 96 of file LArWheelCalculator.h.

96 { return m_HalfWaveLength; }

◆ GetisBarrette()

bool LArWheelCalculator::GetisBarrette ( ) const
inline

Definition at line 104 of file LArWheelCalculator.h.

104 { return m_isBarrette; }

◆ GetisBarretteCalib()

bool LArWheelCalculator::GetisBarretteCalib ( ) const
inline

Definition at line 105 of file LArWheelCalculator.h.

105 { return m_isBarretteCalib; }

◆ GetisElectrode()

bool LArWheelCalculator::GetisElectrode ( ) const
inline

Definition at line 102 of file LArWheelCalculator.h.

102 { return m_isElectrode; }

◆ GetisInner()

bool LArWheelCalculator::GetisInner ( ) const
inline

Definition at line 103 of file LArWheelCalculator.h.

103 { return m_isInner; }

◆ GetisModule()

bool LArWheelCalculator::GetisModule ( ) const
inline

Definition at line 101 of file LArWheelCalculator.h.

101 { return m_isModule; }

◆ GetLastFan()

int LArWheelCalculator::GetLastFan ( ) const
inline

Definition at line 116 of file LArWheelCalculator.h.

116 { return m_LastFan; }

◆ GetNumberOfFans()

int LArWheelCalculator::GetNumberOfFans ( ) const
inline

Definition at line 92 of file LArWheelCalculator.h.

92 { return m_NumberOfFans; }

◆ GetNumberOfHalfWaves()

int LArWheelCalculator::GetNumberOfHalfWaves ( ) const
inline

Definition at line 91 of file LArWheelCalculator.h.

91 { return m_NumberOfHalfWaves; }

◆ GetNumberOfWaves()

int LArWheelCalculator::GetNumberOfWaves ( ) const
inline

Definition at line 90 of file LArWheelCalculator.h.

90 { return m_NumberOfWaves; }

◆ GetPhiGap()

int LArWheelCalculator::GetPhiGap ( const CLHEP::Hep3Vector &  p) const
inline

Definition at line 138 of file LArWheelCalculator.h.

138 { return GetPhiGapAndSide(p).first; }

◆ GetPhiGapAndSide()

std::pair< int, int > LArWheelCalculator::GetPhiGapAndSide ( const CLHEP::Hep3Vector &  p) const

Definition at line 98 of file LArWheelCalculatorGeometry.cxx.

99 {
100  return m_fanCalcImpl->GetPhiGapAndSide(p);
101 }

◆ GetQuarterWaveLength()

double LArWheelCalculator::GetQuarterWaveLength ( ) const
inline

Definition at line 97 of file LArWheelCalculator.h.

97 { return m_QuarterWaveLength; }

◆ GetStartGapNumber()

int LArWheelCalculator::GetStartGapNumber ( ) const
inline

Definition at line 118 of file LArWheelCalculator.h.

118 { return m_ZeroGapNumber; }

◆ GetStraightStartSection()

double LArWheelCalculator::GetStraightStartSection ( ) const
inline

Definition at line 82 of file LArWheelCalculator.h.

82 { return m_StraightStartSection; }

◆ GetWheelInnerRadius() [1/2]

double LArWheelCalculator::GetWheelInnerRadius ( std::array< double, 2 > &  rInner) const

Definition at line 493 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelInnerRadius() [2/2]

double LArWheelCalculator::GetWheelInnerRadius ( std::array< double, 3 > &  rInner) const

Definition at line 504 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelOuterRadius() [1/2]

void LArWheelCalculator::GetWheelOuterRadius ( std::array< double, 2 > &  rOuter) const

Definition at line 525 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelOuterRadius() [2/2]

void LArWheelCalculator::GetWheelOuterRadius ( std::array< double, 3 > &  rOuter) const

Definition at line 535 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelRefPoint()

double LArWheelCalculator::GetWheelRefPoint ( ) const
inline

Definition at line 98 of file LArWheelCalculator.h.

98 { return m_zWheelRefPoint; }

◆ GetWheelThickness()

double LArWheelCalculator::GetWheelThickness ( ) const
inline

Definition at line 80 of file LArWheelCalculator.h.

80 { return m_WheelThickness; }

◆ GetZeroFanPhi()

double LArWheelCalculator::GetZeroFanPhi ( ) const
inline

Definition at line 89 of file LArWheelCalculator.h.

89 { return m_ZeroFanPhi; }

◆ inner_wheel_init()

void LArWheelCalculator::inner_wheel_init ( const EMECData &  emecData)
private

Definition at line 408 of file LArWheelCalculator.cxx.

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 }

◆ LArWheelCalculatorTypeString()

const char * LArWheelCalculator::LArWheelCalculatorTypeString ( LArG4::LArWheelCalculator_t  type)
static

Definition at line 65 of file LArWheelCalculator.cxx.

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 }

◆ module_init()

void LArWheelCalculator::module_init ( )
private

Definition at line 479 of file LArWheelCalculator.cxx.

480 {
481  m_isModule = true;
482  m_LastFan = m_NumberOfFans / 8;
483  m_FirstFan = 0;
484  m_ZeroFanPhi = - m_LastFan / 2 * m_FanStepOnPhi;
485 }

◆ NearestPointOnNeutralFibre()

CLHEP::Hep3Vector LArWheelCalculator::NearestPointOnNeutralFibre ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const

Definition at line 113 of file LArWheelCalculatorGeometry.cxx.

114 {
115  return m_distanceCalcImpl->NearestPointOnNeutralFibre(P, fan_number);
116 }

◆ NearestPointOnNeutralFibre_asVector()

std::vector< double > LArWheelCalculator::NearestPointOnNeutralFibre_asVector ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const

Definition at line 118 of file LArWheelCalculatorGeometry.cxx.

119 {
120  CLHEP::Hep3Vector np = NearestPointOnNeutralFibre(p, fan_number);
121  return std::vector<double> { np.x(), np.y(), np.z() };
122 }

◆ operator=()

LArWheelCalculator& LArWheelCalculator::operator= ( const LArWheelCalculator &  )
delete

◆ outer_wheel_init()

void LArWheelCalculator::outer_wheel_init ( const EMECData &  emecData)
private

Definition at line 424 of file LArWheelCalculator.cxx.

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 }

◆ parameterized_sin()

void LArWheelCalculator::parameterized_sin ( const double  r,
double &  sin_a,
double &  cos_a 
) const
private

Definition at line 21 of file LArWheelCalculatorGeometry.cxx.

22 {
23  const double r2 = r*r;
24  const double r3 = r2*r;
25  const double r4 = r2*r2;
26 #if LARWC_SINCOS_POLY > 4
27  const double r5 = r4*r;
28 #endif
29  sin_a = m_sin_parametrization[0]
30  + m_sin_parametrization[1]*r
31  + m_sin_parametrization[2]*r2
32  + m_sin_parametrization[3]*r3
33  + m_sin_parametrization[4]*r4
34 #if LARWC_SINCOS_POLY > 4
35  + m_sin_parametrization[5]*r5
36 #endif
37  ;
38  cos_a = sqrt(1. - sin_a*sin_a);
39 }

◆ parameterized_sincos()

void LArWheelCalculator::parameterized_sincos ( const double  r,
double &  sin_a,
double &  cos_a 
) const
private

Definition at line 41 of file LArWheelCalculatorGeometry.cxx.

42 {
43  const double r2 = r*r;
44  const double r3 = r2*r;
45  const double r4 = r2*r2;
46 #if LARWC_SINCOS_POLY > 4
47  const double r5 = r4*r;
48 #endif
49  sin_a = m_sin_parametrization[0]
50  + m_sin_parametrization[1]*r
51  + m_sin_parametrization[2]*r2
52  + m_sin_parametrization[3]*r3
53  + m_sin_parametrization[4]*r4
54 #if LARWC_SINCOS_POLY > 4
55  + m_sin_parametrization[5]*r5
56 #endif
57  ;
58  cos_a = m_cos_parametrization[0]
59  + m_cos_parametrization[1]*r
60  + m_cos_parametrization[2]*r2
61  + m_cos_parametrization[3]*r3
62  + m_cos_parametrization[4]*r4
63 #if LARWC_SINCOS_POLY > 4
64  + m_cos_parametrization[5]*r5
65 #endif
66  ;
67 }

◆ parameterized_slant_angle()

double LArWheelCalculator::parameterized_slant_angle ( double  r) const

Calculates wave slant angle using parametrization for current wheel for given distance from calorimeter axis.

Definition at line 71 of file LArWheelCalculatorGeometry.cxx.

72 {
73  const double r2 = r*r;
74  const double r3 = r2*r;
75  const double r4 = r2*r2;
76  const double result = m_slant_parametrization[0] +
77  r*m_slant_parametrization[1] +
78  r2*m_slant_parametrization[2] +
79  r3*m_slant_parametrization[3] +
80  r4*m_slant_parametrization[4];
81  return result*deg;
82 }

◆ PhiGapNumberForWheel()

int LArWheelCalculator::PhiGapNumberForWheel ( int  i) const

Definition at line 403 of file LArWheelCalculator.cxx.

404 {
405  return m_fanCalcImpl->PhiGapNumberForWheel(i);
406 }

◆ SetStartGapNumber()

void LArWheelCalculator::SetStartGapNumber ( int  n)
inline

Definition at line 119 of file LArWheelCalculator.h.

119 { m_ZeroGapNumber = n; }

◆ type()

virtual LArG4::LArWheelCalculator_t LArWheelCalculator::type ( ) const
inlinevirtual

Definition at line 83 of file LArWheelCalculator.h.

83 { return m_type; }

◆ zShift()

double LArWheelCalculator::zShift ( ) const
inline

Definition at line 87 of file LArWheelCalculator.h.

87 { return m_zShift; }

Friends And Related Function Documentation

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOff

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOff
friend

Definition at line 62 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOn

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOn
friend

Definition at line 63 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan

template<typename SaggingType >
friend class LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan
friend

Definition at line 66 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::ModuleFanCalculator

friend class LArWheelCalculator_Impl::ModuleFanCalculator
friend

Definition at line 64 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::WheelFanCalculator

template<typename SaggingType >
friend class LArWheelCalculator_Impl::WheelFanCalculator
friend

Definition at line 65 of file LArWheelCalculator.h.

Member Data Documentation

◆ m_ActiveLength

double LArWheelCalculator::m_ActiveLength
private

Definition at line 157 of file LArWheelCalculator.h.

◆ m_AtlasZside

int LArWheelCalculator::m_AtlasZside
private

Definition at line 148 of file LArWheelCalculator.h.

◆ m_coldContraction

double LArWheelCalculator::m_coldContraction
private

Definition at line 199 of file LArWheelCalculator.h.

◆ m_cos_parametrization

std::array<double,LARWC_SINCOS_POLY+1> LArWheelCalculator::m_cos_parametrization
private

Definition at line 154 of file LArWheelCalculator.h.

◆ m_dElecFocaltoWRP

double LArWheelCalculator::m_dElecFocaltoWRP
private

Definition at line 163 of file LArWheelCalculator.h.

◆ m_distanceCalcImpl

LArWheelCalculator_Impl::IDistanceCalculator* LArWheelCalculator::m_distanceCalcImpl
private

Definition at line 237 of file LArWheelCalculator.h.

◆ m_dMechFocaltoWRP

double LArWheelCalculator::m_dMechFocaltoWRP
private

Definition at line 162 of file LArWheelCalculator.h.

◆ m_dWRPtoFrontFace

double LArWheelCalculator::m_dWRPtoFrontFace
private

Definition at line 159 of file LArWheelCalculator.h.

◆ m_electrodeInvContraction

double LArWheelCalculator::m_electrodeInvContraction
private

Definition at line 200 of file LArWheelCalculator.h.

◆ m_electrodeTotalThickness

double LArWheelCalculator::m_electrodeTotalThickness
private

Definition at line 198 of file LArWheelCalculator.h.

◆ m_eta_hi

double LArWheelCalculator::m_eta_hi
private

Definition at line 165 of file LArWheelCalculator.h.

◆ m_eta_low

double LArWheelCalculator::m_eta_low
private

Definition at line 165 of file LArWheelCalculator.h.

◆ m_eta_mid

double LArWheelCalculator::m_eta_mid
private

Definition at line 165 of file LArWheelCalculator.h.

◆ m_fanCalcImpl

LArWheelCalculator_Impl::IFanCalculator* LArWheelCalculator::m_fanCalcImpl
private

Definition at line 238 of file LArWheelCalculator.h.

◆ m_FanFoldRadius

double LArWheelCalculator::m_FanFoldRadius
private

Definition at line 174 of file LArWheelCalculator.h.

◆ m_FanHalfThickness

double LArWheelCalculator::m_FanHalfThickness
private

Definition at line 182 of file LArWheelCalculator.h.

◆ m_FanStepOnPhi

double LArWheelCalculator::m_FanStepOnPhi
private

Definition at line 177 of file LArWheelCalculator.h.

◆ m_FirstFan

int LArWheelCalculator::m_FirstFan
private

Definition at line 184 of file LArWheelCalculator.h.

◆ m_glueThickness

double LArWheelCalculator::m_glueThickness
private

Definition at line 197 of file LArWheelCalculator.h.

◆ m_HalfGapBetweenWheels

double LArWheelCalculator::m_HalfGapBetweenWheels
private

Definition at line 160 of file LArWheelCalculator.h.

◆ m_HalfWaveLength

double LArWheelCalculator::m_HalfWaveLength
private

Definition at line 173 of file LArWheelCalculator.h.

◆ m_HalfWheelThickness

double LArWheelCalculator::m_HalfWheelThickness
private

Definition at line 169 of file LArWheelCalculator.h.

◆ m_isBarrette

bool LArWheelCalculator::m_isBarrette
private

Definition at line 190 of file LArWheelCalculator.h.

◆ m_isBarretteCalib

bool LArWheelCalculator::m_isBarretteCalib
private

Definition at line 191 of file LArWheelCalculator.h.

◆ m_isElectrode

bool LArWheelCalculator::m_isElectrode
private

Definition at line 188 of file LArWheelCalculator.h.

◆ m_isInner

bool LArWheelCalculator::m_isInner
private

Definition at line 189 of file LArWheelCalculator.h.

◆ m_isModule

bool LArWheelCalculator::m_isModule
private

Definition at line 187 of file LArWheelCalculator.h.

◆ m_LastFan

int LArWheelCalculator::m_LastFan
private

Definition at line 185 of file LArWheelCalculator.h.

◆ m_leadThicknessInner

double LArWheelCalculator::m_leadThicknessInner
private

Definition at line 194 of file LArWheelCalculator.h.

◆ m_leadThicknessOuter

double LArWheelCalculator::m_leadThicknessOuter
private

Definition at line 195 of file LArWheelCalculator.h.

◆ m_NumberOfFans

int LArWheelCalculator::m_NumberOfFans
private

Definition at line 180 of file LArWheelCalculator.h.

◆ m_NumberOfHalfWaves

int LArWheelCalculator::m_NumberOfHalfWaves
private

Definition at line 179 of file LArWheelCalculator.h.

◆ m_NumberOfWaves

int LArWheelCalculator::m_NumberOfWaves
private

Definition at line 178 of file LArWheelCalculator.h.

◆ m_phiRotation

bool LArWheelCalculator::m_phiRotation
private

Definition at line 150 of file LArWheelCalculator.h.

◆ m_QuarterWaveLength

double LArWheelCalculator::m_QuarterWaveLength
private

Definition at line 172 of file LArWheelCalculator.h.

◆ m_rOuterCutoff

double LArWheelCalculator::m_rOuterCutoff
private

Definition at line 164 of file LArWheelCalculator.h.

◆ m_sagging_parameter

std::vector<std::vector<double> > LArWheelCalculator::m_sagging_parameter
private

Definition at line 155 of file LArWheelCalculator.h.

◆ m_SaggingOn

bool LArWheelCalculator::m_SaggingOn
private

Definition at line 149 of file LArWheelCalculator.h.

◆ m_sin_parametrization

std::array<double,LARWC_SINCOS_POLY+1> LArWheelCalculator::m_sin_parametrization
private

Definition at line 153 of file LArWheelCalculator.h.

◆ m_slant_parametrization

std::array<double,5> LArWheelCalculator::m_slant_parametrization
private

Definition at line 152 of file LArWheelCalculator.h.

◆ m_slant_use_default

bool LArWheelCalculator::m_slant_use_default
private

Definition at line 151 of file LArWheelCalculator.h.

◆ m_steelThickness

double LArWheelCalculator::m_steelThickness
private

Definition at line 196 of file LArWheelCalculator.h.

◆ m_StraightStartSection

double LArWheelCalculator::m_StraightStartSection
private

Definition at line 158 of file LArWheelCalculator.h.

◆ m_type

LArG4::LArWheelCalculator_t LArWheelCalculator::m_type
private

Definition at line 146 of file LArWheelCalculator.h.

◆ m_WheelThickness

double LArWheelCalculator::m_WheelThickness
private

Definition at line 168 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi

double LArWheelCalculator::m_ZeroFanPhi
private

Definition at line 175 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi_ForDetNeaFan

double LArWheelCalculator::m_ZeroFanPhi_ForDetNeaFan
private

Definition at line 176 of file LArWheelCalculator.h.

◆ m_ZeroGapNumber

int LArWheelCalculator::m_ZeroGapNumber
private

Definition at line 183 of file LArWheelCalculator.h.

◆ m_zShift

double LArWheelCalculator::m_zShift
private

Definition at line 166 of file LArWheelCalculator.h.

◆ m_zWheelBackFace

double LArWheelCalculator::m_zWheelBackFace
private

Definition at line 170 of file LArWheelCalculator.h.

◆ m_zWheelFrontFace

double LArWheelCalculator::m_zWheelFrontFace
private

Definition at line 170 of file LArWheelCalculator.h.

◆ m_zWheelRefPoint

double LArWheelCalculator::m_zWheelRefPoint
private

Definition at line 161 of file LArWheelCalculator.h.

The documentation for this class was generated from the following files:
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
get_generator_info.result
result
Definition: get_generator_info.py:21
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
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
DMTest::P
P_v1 P
Definition: P.h:23
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
LArWheelCalculator::inner_wheel_init
void inner_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:408
LArWheelCalculator::type
virtual LArG4::LArWheelCalculator_t type() const
Definition: LArWheelCalculator.h:83
LArWheelCalculator::LArWheelCalculatorTypeString
static const char * LArWheelCalculatorTypeString(LArG4::LArWheelCalculator_t)
Definition: LArWheelCalculator.cxx:65
M_PI
#define M_PI
Definition: ActiveFraction.h:11
deg
#define deg
Definition: SbPolyhedron.cxx:17
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
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
MCP::ScaleSmearParam::r2
@ r2
LArWheelCalculator_Impl::IFanCalculator::GetPhiGapAndSide
virtual std::pair< int, int > GetPhiGapAndSide(const CLHEP::Hep3Vector &p) const =0
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
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
LArWheelCalculator_Impl::IDistanceCalculator::AmplitudeOfSurface
virtual double AmplitudeOfSurface(const CLHEP::Hep3Vector &p, int side, int fan_number) const =0
EMECData::emecparams
std::vector< EMECPARAMS > emecparams
Definition: EMECData.h:133
LArWheelCalculator_Impl::IDistanceCalculator::DistanceToTheNeutralFibre
virtual double DistanceToTheNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const =0
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
EMECData::emecgeometry
std::vector< EMECGEOMETRY > emecgeometry
Definition: EMECData.h:132
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
beamspotman.n
n
Definition: beamspotman.py:731
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
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_Impl::IDistanceCalculator::NearestPointOnNeutralFibre
virtual CLHEP::Hep3Vector NearestPointOnNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const =0
LArWheelCalculator::m_StraightStartSection
double m_StraightStartSection
Definition: LArWheelCalculator.h:158
LArWheelCalculator::GetPhiGapAndSide
std::pair< int, int > GetPhiGapAndSide(const CLHEP::Hep3Vector &p) const
Definition: LArWheelCalculatorGeometry.cxx:98
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_Impl::IFanCalculator::DistanceToTheNearestFan
virtual double DistanceToTheNearestFan(CLHEP::Hep3Vector &p, int &out_fan_number) const =0
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::NearestPointOnNeutralFibre
CLHEP::Hep3Vector NearestPointOnNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const
Definition: LArWheelCalculatorGeometry.cxx:113
LArWheelCalculator::m_HalfWaveLength
double m_HalfWaveLength
Definition: LArWheelCalculator.h:173
LArWheelCalculator::m_ActiveLength
double m_ActiveLength
Definition: LArWheelCalculator.h:157
DEBUG
#define DEBUG
Definition: page_access.h:11
LArWheelCalculator::m_cos_parametrization
std::array< double, LARWC_SINCOS_POLY+1 > m_cos_parametrization
Definition: LArWheelCalculator.h:154
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
LArWheelCalculator::m_sin_parametrization
std::array< double, LARWC_SINCOS_POLY+1 > m_sin_parametrization
Definition: LArWheelCalculator.h:153
LArG4::BackInnerBarretteWheel
@ BackInnerBarretteWheel
Definition: LArWheelCalculatorEnums.h:15
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
LArWheelCalculator::GetFanHalfThickness
double GetFanHalfThickness() const
Definition: LArWheelCalculator.h:99
Generated on Sun Dec 22 2024 21:39:03 for ATLAS Offline Software by   doxygen 1.8.18