ATLAS Offline Software
Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn Class Reference

Implements details of distance calculation to parts of the LAr endcap with sagging taken into account. More...

#include <DistanceCalculatorSaggingOn.h>

Inheritance diagram for LArWheelCalculator_Impl::DistanceCalculatorSaggingOn:
Collaboration diagram for LArWheelCalculator_Impl::DistanceCalculatorSaggingOn:

Public Types

typedef DistanceCalculatorSaggingOff parent
 

Public Member Functions

 DistanceCalculatorSaggingOn (const std::string &saggingOptions, LArWheelCalculator *lwc)
 Constructor. More...
 
const LArWheelCalculator * lwc () const
 Return the calculator: More...
 
Geometry methods
virtual double DistanceToTheNeutralFibre (const CLHEP::Hep3Vector &p, int fan_number) const
 
virtual CLHEP::Hep3Vector NearestPointOnNeutralFibre (const CLHEP::Hep3Vector &p, int fan_number) const
 
virtual double AmplitudeOfSurface (const CLHEP::Hep3Vector &P, int side, int fan_number) const
 
Geometry methods
virtual double DistanceToTheNeutralFibre_ref (const CLHEP::Hep3Vector &p, int fan_number) const
 
virtual CLHEP::Hep3Vector NearestPointOnNeutralFibre_ref (const CLHEP::Hep3Vector &p, int fan_number) const
 

Private Member Functions

double get_sagging (const CLHEP::Hep3Vector &P, int fan_number) const
 
void init_sagging_parameters ()
 

Private Attributes

std::vector< std::vector< double > > m_sagging_parameter
 
std::string m_saggingOptions
 
LArWheelCalculator * m_lwc
 
double m_EndQuarterWave
 

Detailed Description

Implements details of distance calculation to parts of the LAr endcap with sagging taken into account.

Definition at line 18 of file DistanceCalculatorSaggingOn.h.

Member Typedef Documentation

◆ parent

typedef DistanceCalculatorSaggingOff LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::parent

Definition at line 23 of file DistanceCalculatorSaggingOn.h.

Constructor & Destructor Documentation

◆ DistanceCalculatorSaggingOn()

LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::DistanceCalculatorSaggingOn ( const std::string &  saggingOptions,
LArWheelCalculator *  lwc 
)

Constructor.

Definition at line 27 of file DistanceCalculatorSaggingOn.cxx.

29  : parent(lwc),
30  m_saggingOptions(saggingOptions)
31 
32  {
33  init_sagging_parameters();
34  }

Member Function Documentation

◆ AmplitudeOfSurface()

double LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::AmplitudeOfSurface ( const CLHEP::Hep3Vector &  P,
int  side,
int  fan_number 
) const
virtual

Reimplemented from LArWheelCalculator_Impl::DistanceCalculatorSaggingOff.

Definition at line 130 of file DistanceCalculatorSaggingOn.cxx.

130  {
131  return parent::AmplitudeOfSurface(p, side, fan_number) - get_sagging(p, fan_number);
132  }

◆ DistanceToTheNeutralFibre()

double LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::DistanceToTheNeutralFibre ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const
virtual

Reimplemented from LArWheelCalculator_Impl::DistanceCalculatorSaggingOff.

Definition at line 120 of file DistanceCalculatorSaggingOn.cxx.

120  {
121  CLHEP::Hep3Vector sagging_corrected( p.x()+get_sagging(p, fan_number), p.y(), p.z() );
122  return parent::DistanceToTheNeutralFibre(sagging_corrected, fan_number);
123  }

◆ DistanceToTheNeutralFibre_ref()

double LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::DistanceToTheNeutralFibre_ref ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const
virtualinherited

Definition at line 147 of file DistanceCalculatorSaggingOff.cxx.

149  {
150  double z = P.z() - lwc()->m_StraightStartSection;
151  double x = P.x();
152 
153 #ifdef LWC_PARAM_ANGLE //old variant
154  const double alpha = lwc()->parameterized_slant_angle(P.y());
155  CxxUtils::sincos scalpha(alpha);
156  double cos_a = scalpha.cs, sin_a = scalpha.sn;
157 #else // parameterized sine
158  double cos_a, sin_a;
159  lwc()->m_vsincos_par.eval(P.y(), sin_a, cos_a);
160 #endif
161 
162  bool sqw = false;
163  if(z > lwc()->m_QuarterWaveLength){
164  if(z < m_EndQuarterWave){ // regular half-waves
165  unsigned int nhwave = (unsigned int)(z / lwc()->m_HalfWaveLength + 0.5);
166  z -= lwc()->m_HalfWaveLength * nhwave;
167  const double straight_part = (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
168  nhwave &= 1U;
169  if(nhwave == 0) sin_a = - sin_a;
170  double z_prime = z * cos_a + x * sin_a;
171  const double x_prime = z * sin_a - x * cos_a;
172  if(z_prime > straight_part){ // up fold region
173  const double dz = z_prime - straight_part;
174  if(nhwave == 0){
175  const double dx = x_prime + lwc()->m_FanFoldRadius;
176  return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
177  } else {
178  const double dx = x_prime - lwc()->m_FanFoldRadius;
179  return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
180  }
181  }
182  z_prime += straight_part;
183  if(z_prime > 0){
184  return x_prime; // straight part of the quarter-wave
185  } else { // low fold region
186  const double &dz = z_prime;
187  if(nhwave == 0){
188  const double dx = x_prime - lwc()->m_FanFoldRadius;
189  return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
190  } else {
191  const double dx = x_prime + lwc()->m_FanFoldRadius;
192  return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
193  }
194  }
195  } else { // ending quarter-wave
196  z = lwc()->m_ActiveLength - z;
197  }
198  } else { // starting quarter-wave
199  x = - x;
200  sqw = true;
201  }
202 
203  // start and finish quarter-waves
204  const double tan_beta = sin_a/(1.0 + cos_a); //tan(alpha * 0.5);
205  const double local_straight_section = lwc()->m_FanFoldRadius * tan_beta;
206  if(z < - local_straight_section &&
207  ( x < lwc()->m_FanFoldRadius ||
208  x < - lwc()->m_StraightStartSection * z / local_straight_section / tan_beta ))
209  {
210  return sqw? x: (-x);
211  }
212  else {
213  const double z_prime = z * cos_a + x * sin_a;
214  const double x_prime = x * cos_a - z * sin_a;
215  if (z_prime < local_straight_section) { // start fold region
216  const double dz = local_straight_section - z_prime;
217  const double dx = x_prime - lwc()->m_FanFoldRadius;
218  if(sqw) return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
219  else return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
220  } else {
221  const double straight_part =
222  (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
223  if (z_prime <= straight_part) { // straight part of quarter-wave
224  return sqw? x_prime: (-x_prime);
225  } else { // regular fold region of the quarter-wave
226  const double dz = straight_part - z_prime;
227  const double dx = x_prime + lwc()->m_FanFoldRadius;
228  if(sqw) return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
229  else return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
230  }
231  }
232  }
233  // ???
234  std::abort();
235  }

◆ get_sagging()

double LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::get_sagging ( const CLHEP::Hep3Vector &  P,
int  fan_number 
) const
private

Definition at line 136 of file DistanceCalculatorSaggingOn.cxx.

136  {
137 #ifdef HARDDEBUG
138  std::cout << "get_sagging: MFN = " << fan_number << std::endl;
139 #endif
140  double dx = P.z() / lwc()->m_HalfWheelThickness - 1.;
141  dx *= dx;
142  dx = 1. - dx;
143  //dx *= SaggingAmplitude * sin(FanStepOnPhi * m_fan_number + ZeroFanPhi);
144  //int n = m_fan_number;
145  //if(n < 0) n += m_NumberOfFans;
146  //n += m_ZeroGapNumber;
147  //if(n >= m_NumberOfFans) n -= m_NumberOfFans;
148  //const std::vector<double>& sp = m_sagging_parameter[n];
149  const std::vector<double>& sp = m_sagging_parameter[fan_number];
150  double R = P.r() / mm;
151  double r = R;
152  double result = sp[0];
153  result += R * sp[1];
154  R *= r;
155  result += R * sp[2];
156  R *= r;
157  result += R * sp[3];
158  R *= r;
159  result += R * sp[4];
160 
161 #ifdef HARDDEBUG
162  /*printf("get_sagging: (%6.3f, %6.3f, %6.3f) %6.3f; MFN %4d;"
163  "n %3d; sp %6.4f %6.4f; dx %6.3f; %.6f\n", P.x()/mm, P.y()/mm, P.z()/mm,
164  r, m_fan_number, n, sp[0], sp[1], dx, result*dx);*/
165  printf("get_sagging: (%6.3f, %6.3f, %6.3f) %6.3f;"
166  " sp %6.4f %6.4f; dx %6.3f; %.6f\n", P.x()/mm, P.y()/mm, P.z()/mm,
167  r, sp[0], sp[1], dx, result*dx);
168 #endif //HARDDEBUG
169 
170  return result * dx;
171  }

◆ init_sagging_parameters()

void LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::init_sagging_parameters ( )
private

Definition at line 36 of file DistanceCalculatorSaggingOn.cxx.

37  {
38 
39  // Get pointer to the message service
40 #ifndef PORTABLE_LAR_SHAPE
41  ISvcLocator* svcLocator = Gaudi::svcLocator();
42  IMessageSvc* msgSvc;
43  StatusCode status = svcLocator->service("MessageSvc", msgSvc);
44  if(status.isFailure()){
45  throw std::runtime_error("LArWheelCalculator constructor: \
46  cannot initialze message service");
47  }
48  MsgStream msg(msgSvc, "LArWheelCalculator_Impl::DistanceCalculatorSaggingOn");
49 #else
50  PortableMsgStream msg("LArWheelCalculator_Impl::DistanceCalculatorSaggingOn");
51 #endif
52  std::string sagging_opt_value = m_saggingOptions;
53  m_sagging_parameter.resize (lwc()->m_NumberOfFans, std::vector<double> (5, 0.));
54  // if(m_SaggingOn) {
55  if(sagging_opt_value.substr(0, 4) == "file"){
56  std::string sag_file = sagging_opt_value.substr(5);
57  msg << MSG::DEBUG
58  << "geting sagging parameters from file "
59  << sag_file << " ..." << endmsg;
60  FILE *F = fopen(sag_file.c_str(), "r");
61  if(F == 0){
62  msg << MSG::FATAL
63  << "cannot open EMEC sagging parameters file "
64  << sag_file
65  << endmsg;
66  throw std::runtime_error("LArWheelCalculator: read sagging parameters from file");
67  }
68  int s, w, t, n;
69  double p0, p1, p2, p3, p4;
70  while(!feof(F) &&
71  fscanf(F, "%80d %80d %80d %80d %80le %80le %80le %80le %80le",
72  &s, &w, &t, &n, &p0, &p1, &p2, &p3, &p4) == 9)
73  {
74  if(s == lwc()->m_AtlasZside &&
75  ((w == 0 && lwc()->m_isInner) || (w == 1 && !lwc()->m_isInner)) &&
76  ((t == 0 && !lwc()->m_isElectrode) || (t == 1 && lwc()->m_isElectrode)) &&
77  (n >= 0 && n < lwc()->m_NumberOfFans))
78  {
79  m_sagging_parameter[n][0] = p0;
80  m_sagging_parameter[n][1] = p1;
81  m_sagging_parameter[n][2] = p2;
82  m_sagging_parameter[n][3] = p3;
83  m_sagging_parameter[n][4] = p4;
84  msg << MSG::VERBOSE
85  << "sagging for " << s << " " << w << " " << t
86  << " " << n << ": " << p0 << " " << p1 << " "
87  << p2 << " " << p3 << endmsg;
88  }
89  }
90  fclose(F);
91  } else {
92  double a, b, c, d;
93  if(sscanf(sagging_opt_value.c_str(), "%80le %80le %80le %80le", &a, &b, &c, &d) != 4){
94  msg << MSG::ERROR
95  << "wrong value(s) "
96  << " for EMEC sagging parameters: "
97  << sagging_opt_value << ", defaults are used" << endmsg;
98  } else {
99  for(int j = 0; j < lwc()->m_NumberOfFans; j ++){
100  if(lwc()->m_isInner){
101  m_sagging_parameter[j][1] = a;
102  m_sagging_parameter[j][0] = b * mm;
103  } else {
104  m_sagging_parameter[j][1] = c;
105  m_sagging_parameter[j][0] = d * mm;
106  }
107  }
108  }
109  }
110  // }
111  msg << MSG::INFO << "Sagging parameters : " << m_sagging_parameter[0][0] << " " << m_sagging_parameter[0][1] << endmsg
112  << "Sagging parameters : " << m_sagging_parameter[1][0] << " " << m_sagging_parameter[1][1] << endmsg;
113  }

◆ lwc()

const LArWheelCalculator* LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::lwc ( ) const
inlineinherited

Return the calculator:

Definition at line 38 of file DistanceCalculatorSaggingOff.h.

38 { return m_lwc; };

◆ NearestPointOnNeutralFibre()

CLHEP::Hep3Vector LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::NearestPointOnNeutralFibre ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const
virtual

Reimplemented from LArWheelCalculator_Impl::DistanceCalculatorSaggingOff.

Definition at line 125 of file DistanceCalculatorSaggingOn.cxx.

125  {
126  CLHEP::Hep3Vector sagging_corrected( p.x()+get_sagging(p, fan_number), p.y(), p.z() );
127  return parent::NearestPointOnNeutralFibre(sagging_corrected, fan_number);
128  }

◆ NearestPointOnNeutralFibre_ref()

CLHEP::Hep3Vector LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::NearestPointOnNeutralFibre_ref ( const CLHEP::Hep3Vector &  p,
int  fan_number 
) const
virtualinherited

Definition at line 325 of file DistanceCalculatorSaggingOff.cxx.

326  {
327  CLHEP::Hep3Vector result;
328  double z = P.z() - lwc()->m_StraightStartSection;
329  double x = P.x();
330  double y = P.y();
331 
332 #ifdef LWC_PARAM_ANGLE //old variant
333  const double alpha = lwc()->parameterized_slant_angle(P.y());
334  CxxUtils::sincos scalpha(alpha);
335  double cos_a = scalpha.cs, sin_a = scalpha.sn;
336 #else // parameterized sine
337  double cos_a, sin_a;
338  lwc()->m_vsincos_par.eval(P.y(), sin_a, cos_a);
339 #endif
340 
341  bool sqw = false;
342  if(z > lwc()->m_QuarterWaveLength){
343  if(z < m_EndQuarterWave){ // regular half-waves
344  unsigned int nhwave = (unsigned int)(z / lwc()->m_HalfWaveLength + 0.5);
345  const double zshift = lwc()->m_HalfWaveLength * nhwave;
346  z -= zshift;
347  const double straight_part =
348  (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
349  nhwave &= 1U;
350  if(nhwave == 0) sin_a = - sin_a;
351  const double z_prime = z * cos_a + x * sin_a;
352  if(z_prime > straight_part){ // up fold
353  const double x_prime = x * cos_a - z * sin_a;
354  const double dz = straight_part - z_prime;
355  double a1 = atan(fabs(dz / (x_prime + lwc()->m_FanFoldRadius)));
356  const double x1 = lwc()->m_FanFoldRadius * (cos(a1) - 1.);
357  const double z1 = straight_part + lwc()->m_FanFoldRadius * sin(a1);
358  result.set(x1*cos_a - z1*sin_a, y, z1*cos_a + z1*sin_a);
359  return result;
360  } else if(z_prime > -straight_part){ // straight part
361  result.set(-z_prime * sin_a, y, z_prime*cos_a + zshift);
362  return result;
363  } else { // low fold
364  const double x_prime = x * cos_a - z * sin_a;
365  const double dz = straight_part + z_prime;
366  double a1 = atan(fabs(dz / (x_prime + lwc()->m_FanFoldRadius)));
367  const double x1 = lwc()->m_FanFoldRadius * (cos(a1) - 1.);
368  const double z1 = straight_part + lwc()->m_FanFoldRadius * sin(a1);
369  result.set(x1*cos_a - z1*sin_a, y, z1*cos_a + z1*sin_a);
370  return result;
371  }
372  } else { // ending quarter-wave
373  z = lwc()->m_ActiveLength - z;
374  }
375  } else { // starting quarter-wave
376  x = - x;
377  sqw = true;
378  }
379 
380  // start and finish quarter-waves
381  const double tan_beta = sin_a / (1.0 + cos_a);
382  const double local_straight_section = lwc()->m_FanFoldRadius * tan_beta;
383  if(z < - local_straight_section &&
384  (x < lwc()->m_FanFoldRadius ||
385  x < - lwc()->m_StraightStartSection * z / local_straight_section / tan_beta))
386  {
387  result.set(0., y, z);
388  }
389  else {
390  const double z_prime = z * cos_a + x * sin_a;
391  const double x_prime = x * cos_a - z * sin_a;
392  if(z_prime < local_straight_section) {
393  double a = fabs(atan((local_straight_section - z_prime) / (x_prime - lwc()->m_FanFoldRadius)));
394  result.set(lwc()->m_FanFoldRadius * (1 - cos(a)), y, local_straight_section - lwc()->m_FanFoldRadius * sin(a));
395  } else {
396  double straight_part = (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
397  if(z_prime <= straight_part) {
398  result.set(0., y, z_prime);
399  } else {
400  double a = fabs(atan((straight_part - z_prime) / (x_prime + lwc()->m_FanFoldRadius)) );
401  result.set(lwc()->m_FanFoldRadius * (cos(a) - 1), y, straight_part + lwc()->m_FanFoldRadius * sin(a));
402  }
403  }
404  result.rotateY(asin(sin_a));
405  }
406  if(sqw) result.setX(-result.x());
407  else result.setZ(lwc()->m_ActiveLength - result.z());
408  result.setZ(result.z() + lwc()->m_StraightStartSection);
409  return result;
410  }

Member Data Documentation

◆ m_EndQuarterWave

double LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::m_EndQuarterWave
privateinherited

Definition at line 43 of file DistanceCalculatorSaggingOff.h.

◆ m_lwc

LArWheelCalculator* LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::m_lwc
privateinherited

Definition at line 42 of file DistanceCalculatorSaggingOff.h.

◆ m_sagging_parameter

std::vector<std::vector<double> > LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::m_sagging_parameter
private

Definition at line 41 of file DistanceCalculatorSaggingOn.h.

◆ m_saggingOptions

std::string LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::m_saggingOptions
private

Definition at line 42 of file DistanceCalculatorSaggingOn.h.

The documentation for this class was generated from the following files:
beamspotman.r
def r
Definition: beamspotman.py:676
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::m_sagging_parameter
std::vector< std::vector< double > > m_sagging_parameter
Definition: DistanceCalculatorSaggingOn.h:41
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::parent
DistanceCalculatorSaggingOff parent
Definition: DistanceCalculatorSaggingOn.h:23
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
IDTPM::R
float R(const U &p)
Definition: TrackParametersHelper.h:101
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
hist_file_dump.d
d
Definition: hist_file_dump.py:137
LArWheelCalculator::parameterized_slant_angle
double parameterized_slant_angle(double) const
Calculates wave slant angle using parametrization for current wheel for given distance from calorimet...
Definition: LArWheelCalculatorGeometry.cxx:71
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
x
#define x
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
ParticleJetTools::p3
Amg::Vector3D p3(const xAOD::TruthVertex *p)
Definition: ParticleJetLabelCommon.cxx:55
TRT::Hit::side
@ side
Definition: HitInfo.h:83
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::DistanceToTheNeutralFibre
virtual double DistanceToTheNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const
Definition: DistanceCalculatorSaggingOff.cxx:29
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::get_sagging
double get_sagging(const CLHEP::Hep3Vector &P, int fan_number) const
Definition: DistanceCalculatorSaggingOn.cxx:136
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
z
#define z
beamspotman.n
n
Definition: beamspotman.py:731
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_StraightStartSection
double m_StraightStartSection
Definition: LArWheelCalculator.h:154
LArWheelCalculator::m_NumberOfFans
int m_NumberOfFans
Definition: LArWheelCalculator.h:176
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::AmplitudeOfSurface
virtual double AmplitudeOfSurface(const CLHEP::Hep3Vector &P, int side, int fan_number) const
Definition: DistanceCalculatorSaggingOff.cxx:418
LArWheelCalculator::m_HalfWheelThickness
double m_HalfWheelThickness
Definition: LArWheelCalculator.h:165
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::NearestPointOnNeutralFibre
virtual CLHEP::Hep3Vector NearestPointOnNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const
Definition: DistanceCalculatorSaggingOff.cxx:237
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::m_EndQuarterWave
double m_EndQuarterWave
Definition: DistanceCalculatorSaggingOff.h:43
LArWheelCalculator::m_QuarterWaveLength
double m_QuarterWaveLength
Definition: LArWheelCalculator.h:168
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
LArWheelCalculator::m_FanFoldRadius
double m_FanFoldRadius
Definition: LArWheelCalculator.h:170
a
TList * a
Definition: liststreamerinfos.cxx:10
y
#define y
LArWheelCalculator::m_HalfWaveLength
double m_HalfWaveLength
Definition: LArWheelCalculator.h:169
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::m_lwc
LArWheelCalculator * m_lwc
Definition: DistanceCalculatorSaggingOff.h:38
LArWheelCalculator::m_ActiveLength
double m_ActiveLength
Definition: LArWheelCalculator.h:153
DEBUG
#define DEBUG
Definition: page_access.h:11
F
#define F(x, y, z)
Definition: MD5.cxx:112
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
CxxUtils::sincos
Helper to simultaneously calculate sin and cos of the same angle.
Definition: sincos.h:76
merge.status
status
Definition: merge.py:17
LArWheelCalculator::m_isInner
bool m_isInner
Definition: LArWheelCalculator.h:185
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::init_sagging_parameters
void init_sagging_parameters()
Definition: DistanceCalculatorSaggingOn.cxx:36
LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::m_saggingOptions
std::string m_saggingOptions
Definition: DistanceCalculatorSaggingOn.h:42
python.compressB64.c
def c
Definition: compressB64.py:93
LArWheelCalculator_Impl::DistanceCalculatorSaggingOff::lwc
const LArWheelCalculator * lwc() const
Return the calculator:
Definition: DistanceCalculatorSaggingOff.h:38
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
Generated on Fri Jul 5 2024 22:18:59 for ATLAS Offline Software by   doxygen 1.8.18