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 (double *) const
 
void GetWheelOuterRadius (double *) 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 57 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  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 }

◆ ~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 214 of file LArWheelCalculator.h.

214  {
215  int res_fan_number = fan_number;
216  if(res_fan_number < 0) res_fan_number += m_NumberOfFans;
217  res_fan_number += m_ZeroGapNumber;
218  if(res_fan_number >= m_NumberOfFans) res_fan_number -= m_NumberOfFans;
219  return res_fan_number;
220  }

◆ 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 92 of file LArWheelCalculator.h.

92 { return m_ActiveLength; }

◆ GetAtlasZside()

int LArWheelCalculator::GetAtlasZside ( ) const
inline

Definition at line 84 of file LArWheelCalculator.h.

84 { return m_AtlasZside; }

◆ GetdWRPtoFrontFace()

double LArWheelCalculator::GetdWRPtoFrontFace ( ) const
inline

Definition at line 79 of file LArWheelCalculator.h.

79 { return m_dWRPtoFrontFace; }

◆ GetElecFocaltoWRP()

double LArWheelCalculator::GetElecFocaltoWRP ( ) const
inline

Definition at line 108 of file LArWheelCalculator.h.

108 { return m_dElecFocaltoWRP; }

◆ GetFanFoldRadius()

double LArWheelCalculator::GetFanFoldRadius ( ) const
inline

Definition at line 86 of file LArWheelCalculator.h.

86 { return m_FanFoldRadius; }

◆ GetFanHalfThickness() [1/2]

double LArWheelCalculator::GetFanHalfThickness ( ) const
inline

Definition at line 97 of file LArWheelCalculator.h.

97 { return m_FanHalfThickness; }

◆ GetFanHalfThickness() [2/2]

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

Definition at line 443 of file LArWheelCalculator.cxx.

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 }

◆ GetFanStepOnPhi()

double LArWheelCalculator::GetFanStepOnPhi ( ) const
inline

Definition at line 93 of file LArWheelCalculator.h.

93 { return m_FanStepOnPhi; }

◆ GetFirstFan()

int LArWheelCalculator::GetFirstFan ( ) const
inline

Definition at line 111 of file LArWheelCalculator.h.

111 { return m_FirstFan; }

◆ GetHalfWaveLength()

double LArWheelCalculator::GetHalfWaveLength ( ) const
inline

Definition at line 94 of file LArWheelCalculator.h.

94 { return m_HalfWaveLength; }

◆ GetisBarrette()

bool LArWheelCalculator::GetisBarrette ( ) const
inline

Definition at line 102 of file LArWheelCalculator.h.

102 { return m_isBarrette; }

◆ GetisBarretteCalib()

bool LArWheelCalculator::GetisBarretteCalib ( ) const
inline

Definition at line 103 of file LArWheelCalculator.h.

103 { return m_isBarretteCalib; }

◆ GetisElectrode()

bool LArWheelCalculator::GetisElectrode ( ) const
inline

Definition at line 100 of file LArWheelCalculator.h.

100 { return m_isElectrode; }

◆ GetisInner()

bool LArWheelCalculator::GetisInner ( ) const
inline

Definition at line 101 of file LArWheelCalculator.h.

101 { return m_isInner; }

◆ GetisModule()

bool LArWheelCalculator::GetisModule ( ) const
inline

Definition at line 99 of file LArWheelCalculator.h.

99 { return m_isModule; }

◆ GetLastFan()

int LArWheelCalculator::GetLastFan ( ) const
inline

Definition at line 112 of file LArWheelCalculator.h.

112 { return m_LastFan; }

◆ GetNumberOfFans()

int LArWheelCalculator::GetNumberOfFans ( ) const
inline

Definition at line 90 of file LArWheelCalculator.h.

90 { return m_NumberOfFans; }

◆ GetNumberOfHalfWaves()

int LArWheelCalculator::GetNumberOfHalfWaves ( ) const
inline

Definition at line 89 of file LArWheelCalculator.h.

89 { return m_NumberOfHalfWaves; }

◆ GetNumberOfWaves()

int LArWheelCalculator::GetNumberOfWaves ( ) const
inline

Definition at line 88 of file LArWheelCalculator.h.

88 { return m_NumberOfWaves; }

◆ GetPhiGap()

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

Definition at line 134 of file LArWheelCalculator.h.

134 { 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 95 of file LArWheelCalculator.h.

95 { return m_QuarterWaveLength; }

◆ GetStartGapNumber()

int LArWheelCalculator::GetStartGapNumber ( ) const
inline

Definition at line 114 of file LArWheelCalculator.h.

114 { return m_ZeroGapNumber; }

◆ GetStraightStartSection()

double LArWheelCalculator::GetStraightStartSection ( ) const
inline

Definition at line 80 of file LArWheelCalculator.h.

80 { return m_StraightStartSection; }

◆ GetWheelInnerRadius()

double LArWheelCalculator::GetWheelInnerRadius ( double *  r) const

Definition at line 495 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelOuterRadius()

void LArWheelCalculator::GetWheelOuterRadius ( double *  r) const

Definition at line 520 of file LArWheelCalculator.cxx.

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 }

◆ GetWheelRefPoint()

double LArWheelCalculator::GetWheelRefPoint ( ) const
inline

Definition at line 96 of file LArWheelCalculator.h.

96 { return m_zWheelRefPoint; }

◆ GetWheelThickness()

double LArWheelCalculator::GetWheelThickness ( ) const
inline

Definition at line 78 of file LArWheelCalculator.h.

78 { return m_WheelThickness; }

◆ GetZeroFanPhi()

double LArWheelCalculator::GetZeroFanPhi ( ) const
inline

Definition at line 87 of file LArWheelCalculator.h.

87 { return m_ZeroFanPhi; }

◆ inner_wheel_init()

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

Definition at line 410 of file LArWheelCalculator.cxx.

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 }

◆ 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 481 of file LArWheelCalculator.cxx.

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

◆ 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 426 of file LArWheelCalculator.cxx.

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 }

◆ 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 405 of file LArWheelCalculator.cxx.

406 {
407  return m_fanCalcImpl->PhiGapNumberForWheel(i);
408 }

◆ SetStartGapNumber()

void LArWheelCalculator::SetStartGapNumber ( int  n)
inline

Definition at line 115 of file LArWheelCalculator.h.

115 { m_ZeroGapNumber = n; }

◆ type()

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

Definition at line 81 of file LArWheelCalculator.h.

81 { return m_type; }

◆ zShift()

double LArWheelCalculator::zShift ( ) const
inline

Definition at line 85 of file LArWheelCalculator.h.

85 { return m_zShift; }

Friends And Related Function Documentation

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOff

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOff
friend

Definition at line 60 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOn

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOn
friend

Definition at line 61 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan

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

Definition at line 64 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::ModuleFanCalculator

friend class LArWheelCalculator_Impl::ModuleFanCalculator
friend

Definition at line 62 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::WheelFanCalculator

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

Definition at line 63 of file LArWheelCalculator.h.

Member Data Documentation

◆ m_ActiveLength

double LArWheelCalculator::m_ActiveLength
private

Definition at line 153 of file LArWheelCalculator.h.

◆ m_AtlasZside

int LArWheelCalculator::m_AtlasZside
private

Definition at line 144 of file LArWheelCalculator.h.

◆ m_coldContraction

double LArWheelCalculator::m_coldContraction
private

Definition at line 195 of file LArWheelCalculator.h.

◆ m_cos_parametrization

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

Definition at line 150 of file LArWheelCalculator.h.

◆ m_dElecFocaltoWRP

double LArWheelCalculator::m_dElecFocaltoWRP
private

Definition at line 159 of file LArWheelCalculator.h.

◆ m_distanceCalcImpl

LArWheelCalculator_Impl::IDistanceCalculator* LArWheelCalculator::m_distanceCalcImpl
private

Definition at line 233 of file LArWheelCalculator.h.

◆ m_dMechFocaltoWRP

double LArWheelCalculator::m_dMechFocaltoWRP
private

Definition at line 158 of file LArWheelCalculator.h.

◆ m_dWRPtoFrontFace

double LArWheelCalculator::m_dWRPtoFrontFace
private

Definition at line 155 of file LArWheelCalculator.h.

◆ m_electrodeInvContraction

double LArWheelCalculator::m_electrodeInvContraction
private

Definition at line 196 of file LArWheelCalculator.h.

◆ m_electrodeTotalThickness

double LArWheelCalculator::m_electrodeTotalThickness
private

Definition at line 194 of file LArWheelCalculator.h.

◆ m_eta_hi

double LArWheelCalculator::m_eta_hi
private

Definition at line 161 of file LArWheelCalculator.h.

◆ m_eta_low

double LArWheelCalculator::m_eta_low
private

Definition at line 161 of file LArWheelCalculator.h.

◆ m_eta_mid

double LArWheelCalculator::m_eta_mid
private

Definition at line 161 of file LArWheelCalculator.h.

◆ m_fanCalcImpl

LArWheelCalculator_Impl::IFanCalculator* LArWheelCalculator::m_fanCalcImpl
private

Definition at line 234 of file LArWheelCalculator.h.

◆ m_FanFoldRadius

double LArWheelCalculator::m_FanFoldRadius
private

Definition at line 170 of file LArWheelCalculator.h.

◆ m_FanHalfThickness

double LArWheelCalculator::m_FanHalfThickness
private

Definition at line 178 of file LArWheelCalculator.h.

◆ m_FanStepOnPhi

double LArWheelCalculator::m_FanStepOnPhi
private

Definition at line 173 of file LArWheelCalculator.h.

◆ m_FirstFan

int LArWheelCalculator::m_FirstFan
private

Definition at line 180 of file LArWheelCalculator.h.

◆ m_glueThickness

double LArWheelCalculator::m_glueThickness
private

Definition at line 193 of file LArWheelCalculator.h.

◆ m_HalfGapBetweenWheels

double LArWheelCalculator::m_HalfGapBetweenWheels
private

Definition at line 156 of file LArWheelCalculator.h.

◆ m_HalfWaveLength

double LArWheelCalculator::m_HalfWaveLength
private

Definition at line 169 of file LArWheelCalculator.h.

◆ m_HalfWheelThickness

double LArWheelCalculator::m_HalfWheelThickness
private

Definition at line 165 of file LArWheelCalculator.h.

◆ m_isBarrette

bool LArWheelCalculator::m_isBarrette
private

Definition at line 186 of file LArWheelCalculator.h.

◆ m_isBarretteCalib

bool LArWheelCalculator::m_isBarretteCalib
private

Definition at line 187 of file LArWheelCalculator.h.

◆ m_isElectrode

bool LArWheelCalculator::m_isElectrode
private

Definition at line 184 of file LArWheelCalculator.h.

◆ m_isInner

bool LArWheelCalculator::m_isInner
private

Definition at line 185 of file LArWheelCalculator.h.

◆ m_isModule

bool LArWheelCalculator::m_isModule
private

Definition at line 183 of file LArWheelCalculator.h.

◆ m_LastFan

int LArWheelCalculator::m_LastFan
private

Definition at line 181 of file LArWheelCalculator.h.

◆ m_leadThicknessInner

double LArWheelCalculator::m_leadThicknessInner
private

Definition at line 190 of file LArWheelCalculator.h.

◆ m_leadThicknessOuter

double LArWheelCalculator::m_leadThicknessOuter
private

Definition at line 191 of file LArWheelCalculator.h.

◆ m_NumberOfFans

int LArWheelCalculator::m_NumberOfFans
private

Definition at line 176 of file LArWheelCalculator.h.

◆ m_NumberOfHalfWaves

int LArWheelCalculator::m_NumberOfHalfWaves
private

Definition at line 175 of file LArWheelCalculator.h.

◆ m_NumberOfWaves

int LArWheelCalculator::m_NumberOfWaves
private

Definition at line 174 of file LArWheelCalculator.h.

◆ m_phiRotation

bool LArWheelCalculator::m_phiRotation
private

Definition at line 146 of file LArWheelCalculator.h.

◆ m_QuarterWaveLength

double LArWheelCalculator::m_QuarterWaveLength
private

Definition at line 168 of file LArWheelCalculator.h.

◆ m_rOuterCutoff

double LArWheelCalculator::m_rOuterCutoff
private

Definition at line 160 of file LArWheelCalculator.h.

◆ m_sagging_parameter

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

Definition at line 151 of file LArWheelCalculator.h.

◆ m_SaggingOn

bool LArWheelCalculator::m_SaggingOn
private

Definition at line 145 of file LArWheelCalculator.h.

◆ m_sin_parametrization

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

Definition at line 149 of file LArWheelCalculator.h.

◆ m_slant_parametrization

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

Definition at line 148 of file LArWheelCalculator.h.

◆ m_slant_use_default

bool LArWheelCalculator::m_slant_use_default
private

Definition at line 147 of file LArWheelCalculator.h.

◆ m_steelThickness

double LArWheelCalculator::m_steelThickness
private

Definition at line 192 of file LArWheelCalculator.h.

◆ m_StraightStartSection

double LArWheelCalculator::m_StraightStartSection
private

Definition at line 154 of file LArWheelCalculator.h.

◆ m_type

LArG4::LArWheelCalculator_t LArWheelCalculator::m_type
private

Definition at line 142 of file LArWheelCalculator.h.

◆ m_WheelThickness

double LArWheelCalculator::m_WheelThickness
private

Definition at line 164 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi

double LArWheelCalculator::m_ZeroFanPhi
private

Definition at line 171 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi_ForDetNeaFan

double LArWheelCalculator::m_ZeroFanPhi_ForDetNeaFan
private

Definition at line 172 of file LArWheelCalculator.h.

◆ m_ZeroGapNumber

int LArWheelCalculator::m_ZeroGapNumber
private

Definition at line 179 of file LArWheelCalculator.h.

◆ m_zShift

double LArWheelCalculator::m_zShift
private

Definition at line 162 of file LArWheelCalculator.h.

◆ m_zWheelBackFace

double LArWheelCalculator::m_zWheelBackFace
private

Definition at line 166 of file LArWheelCalculator.h.

◆ m_zWheelFrontFace

double LArWheelCalculator::m_zWheelFrontFace
private

Definition at line 166 of file LArWheelCalculator.h.

◆ m_zWheelRefPoint

double LArWheelCalculator::m_zWheelRefPoint
private

Definition at line 157 of file LArWheelCalculator.h.

The documentation for this class was generated from the following files:
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
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
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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
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
LArWheelCalculator::inner_wheel_init
void inner_wheel_init(const EMECData &)
Definition: LArWheelCalculator.cxx:410
LArWheelCalculator::type
virtual LArG4::LArWheelCalculator_t type() const
Definition: LArWheelCalculator.h:81
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: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
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: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
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: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
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
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
beamspotman.n
n
Definition: beamspotman.py:731
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
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:186
LArG4::InnerLeadWheel
@ InnerLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::m_phiRotation
bool m_phiRotation
Definition: LArWheelCalculator.h:146
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:154
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: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_Impl::IFanCalculator::DistanceToTheNearestFan
virtual double DistanceToTheNearestFan(CLHEP::Hep3Vector &p, int &out_fan_number) const =0
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::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:169
LArWheelCalculator::m_ActiveLength
double m_ActiveLength
Definition: LArWheelCalculator.h:153
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:150
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
LArWheelCalculator::m_sin_parametrization
std::array< double, LARWC_SINCOS_POLY+1 > m_sin_parametrization
Definition: LArWheelCalculator.h:149
LArG4::BackInnerBarretteWheel
@ BackInnerBarretteWheel
Definition: LArWheelCalculatorEnums.h:15
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
LArWheelCalculator::GetFanHalfThickness
double GetFanHalfThickness() const
Definition: LArWheelCalculator.h:97
Generated on Thu Jul 4 2024 21:52:09 for ATLAS Offline Software by   doxygen 1.8.18