This class separates some of the geometry details of the LAr endcap. More...

#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.
geometry methods
double	DistanceToTheNearestFan (CLHEP::Hep3Vector &p, int &out_fan_number) const
	Determines the nearest to the input point fan.
double	DistanceToTheNeutralFibre (const CLHEP::Hep3Vector &p, int fan_number) const
	Calculates aproximate, probably underestimate, distance to the neutral fibre of the vertical fan.
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 58 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.

                                                                                                                  :
  m_type(a_wheelType),
  m_AtlasZside(zside),
  m_distanceCalcImpl(0),
  m_fanCalcImpl(0)
{
 
#ifndef PORTABLE_LAR_SHAPE
  // Get pointer to the message service
  SmartIF<IMessageSvc> msgSvc{Gaudi::svcLocator()->service("MessageSvc")};
  if(!msgSvc.isValid()){
    throw std::runtime_error("LArWheelCalculator constructor: cannot initialze message service");
  }
  MsgStream msg(msgSvc, "LArWheelCalculator");
#else
  PortableMsgStream msg("LArWheelCalculator");
#endif
  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
      << " (type " << LArWheelCalculatorTypeString(m_type)
      << "):" << endmsg;
 
 
  msg << MSG::VERBOSE << "LArWheelCalculator constructor at " << this
      << " (type " << LArWheelCalculatorTypeString(m_type)
      << "):" << endmsg;
 
  msg << MSG::VERBOSE << "compiled with new DTNF" << endmsg;
 
  // Access source of detector parameters.
  msg << MSG::VERBOSE
      << "initializing data members from DB..." << endmsg;
 
  m_zWheelRefPoint       =emecData.emecgeometry[0].Z0*cm;
  m_dMechFocaltoWRP      =emecData.emecgeometry[0].Z1*cm;
  m_dElecFocaltoWRP      =emecData.emecgeometry[0].DCF*cm;
  m_HalfGapBetweenWheels =emecData.emecgeometry[0].DCRACK*cm;
  m_rOuterCutoff         =emecData.emecgeometry[0].RLIMIT*cm;
  m_zShift               =emecData.emecgeometry[0].ZSHIFT*cm;
  
  
  m_eta_hi  =emecData.emecwheelparameters[0].ETAINT;  
  m_eta_mid =emecData.emecwheelparameters[0].ETAEXT;  
  m_eta_low =emecData.emecwheelparameters[1].ETAEXT;  
 
 
 
  m_leadThicknessInner=emecData.emecfan[0].LEADTHICKNESSINNER*mm; 
  m_leadThicknessOuter=emecData.emecfan[0].LEADTHICKNESSOUTER*mm;
  m_steelThickness=emecData.emecfan[0].STEELTHICKNESS*mm;
  m_glueThickness=emecData.emecfan[0].GLUETHICKNESS*mm;
  m_electrodeTotalThickness=emecData.emecfan[0].ELECTRODETOTALTHICKNESS*mm;
  m_coldContraction=emecData.coldcontraction[0].ABSORBERCONTRACTION;
  m_electrodeInvContraction=emecData.coldcontraction[0].ELECTRODEINVCONTRACTION;
 
 
    
  m_ActiveLength         =emecData.emecmagicnumbers[0].ACTIVELENGTH*mm;
  m_StraightStartSection =emecData.emecmagicnumbers[0].STRAIGHTSTARTSECTION*mm;
  m_dWRPtoFrontFace      =emecData.emecmagicnumbers[0].REFTOACTIVE*mm;
 
 
  m_WheelThickness = m_ActiveLength + 2.*m_StraightStartSection;
  m_HalfWheelThickness = m_WheelThickness * 0.5;
 
  std::string pr_opt_value=emecData.emecparams[0].PHIROTATION;
  std::string sagging_opt_value=emecData.emecparams[0].SAGGING;
 
  m_phiRotation =  pr_opt_value == "g3"? true: false;
 
  m_zWheelFrontFace = m_dMechFocaltoWRP + m_dWRPtoFrontFace;
  m_zWheelBackFace = m_zWheelFrontFace + m_WheelThickness;
 
  msg << MSG::DEBUG << "... got these values:" << endmsg 
      << "m_zWheelRefPoint       : " << m_zWheelRefPoint / cm << " [cm]" << endmsg 
      << "m_dMechFocaltoWRP      : " << m_dMechFocaltoWRP / cm << " [cm]" << endmsg 
      << "m_dElecFocaltoWRP      : " << m_dElecFocaltoWRP / cm << " [cm]" << endmsg 
      << "m_HalfGapBetweenWheels : " << m_HalfGapBetweenWheels / cm << " [cm]" << endmsg
      << "m_rOuterCutoff         : " << m_rOuterCutoff / cm << " [cm]" << endmsg
      << "m_zWheelFrontFace      : " << m_zWheelFrontFace / cm << " [cm]" << endmsg
      << "m_zWheelBackFace       : " << m_zWheelBackFace / cm << " [cm]" << endmsg
      << "m_zShift               : " << m_zShift / cm << " [cm]" << endmsg
      << "Phi rotation           : " << (m_phiRotation? "true": "false") << "" << endmsg
      << "eta wheels limits      : " << m_eta_low << ", " << m_eta_mid << ", " << m_eta_hi
      << endmsg;
  msg << MSG::VERBOSE << "hardcoded constants: " << endmsg 
      << "m_WheelThickness       : " << m_WheelThickness / cm << " [cm]" << endmsg 
      << "m_dWRPtoFrontFace      : " << m_dWRPtoFrontFace / cm << " [cm]"
      << endmsg;
 
 
  // Constructor initializes the geometry.
 
  m_isBarrette      = false;
  m_isBarretteCalib = false;
  m_isModule        = false;
  m_isElectrode     = false;
  m_isInner         = false;
  m_FirstFan        = 0;
  m_LastFan         = 0;
 
  switch(m_type){
    case LArG4::BackInnerBarretteWheelCalib:
      m_isBarretteCalib = true;
      /* FALLTHROUGH */
    case LArG4::BackInnerBarretteWheel:
      m_isBarrette = true;
      m_type = LArG4::InnerAbsorberWheel;
      /* FALLTHROUGH */
    case LArG4::InnerAbsorberWheel:
    case LArG4::InnerGlueWheel:
    case LArG4::InnerLeadWheel:
      inner_wheel_init(emecData);
      m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
      if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      break;
    case LArG4::BackOuterBarretteWheelCalib:
      m_isBarretteCalib = true;
      /* FALLTHROUGH */
    case LArG4::BackOuterBarretteWheel:
      m_isBarrette = true;
      m_type = LArG4::OuterAbsorberWheel;
      /* FALLTHROUGH */
    case LArG4::OuterAbsorberWheel:
    case LArG4::OuterGlueWheel:
    case LArG4::OuterLeadWheel:
      outer_wheel_init(emecData);
      m_ZeroFanPhi = m_FanStepOnPhi * 0.5;
      if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      break;
    case LArG4::InnerElectrodWheel:
      inner_wheel_init(emecData);
      m_ZeroFanPhi = 0;
      if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      m_isElectrode = true;
      break;
    case LArG4::OuterElectrodWheel:
      outer_wheel_init(emecData);
      m_ZeroFanPhi = 0;
      if(m_phiRotation) m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      m_isElectrode = true;
      break;
    case LArG4::BackInnerBarretteModuleCalib:
      m_isBarretteCalib = true;
      /* FALLTHROUGH */
    case LArG4::BackInnerBarretteModule:
      m_isBarrette = true;
      m_type = LArG4::InnerAbsorberModule;
      /* FALLTHROUGH */
    case LArG4::InnerAbsorberModule:
      inner_wheel_init(emecData);
      module_init();
      m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
      break;
    case LArG4::BackOuterBarretteModuleCalib:
      m_isBarretteCalib = true;
      /* FALLTHROUGH */
    case LArG4::BackOuterBarretteModule:
      m_isBarrette = true;
      m_type = LArG4::OuterAbsorberModule;
      /* FALLTHROUGH */
    case LArG4::OuterAbsorberModule:
      outer_wheel_init(emecData);
      module_init();
      m_ZeroFanPhi += m_FanStepOnPhi * 0.5;
      // later for all? m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
      break;
    case LArG4::InnerElectrodModule:
      inner_wheel_init(emecData);
      module_init();
      m_FirstFan ++;
      m_isElectrode = true;
      break;
    case LArG4::OuterElectrodModule:
      outer_wheel_init(emecData);
      module_init();
      m_FirstFan ++;
      m_isElectrode = true;
      break;
    default:
      throw std::runtime_error("LArWheelCalculator constructor:unknown LArWheelCalculator_t");
  }
  m_ZeroFanPhi_ForDetNeaFan = m_ZeroFanPhi - m_FanStepOnPhi * 0.5;
  m_NumberOfHalfWaves = m_NumberOfWaves * 2;
  m_HalfWaveLength = m_ActiveLength / m_NumberOfHalfWaves;
  m_QuarterWaveLength = m_HalfWaveLength * 0.5;
  //m_HalfNumberOfFans = m_NumberOfFans / 2;
  m_FanHalfThickness = GetFanHalfThickness(m_type);
 
  // Init sagging
  // value read above
  // std::string sagging_opt_value = (*DB_EMECParams)[0]->getString("SAGGING");
 
  msg << MSG::VERBOSE << "SAGGING value = " << sagging_opt_value << endmsg;
 
  // the same condition is in DistanceCalculatorFactory::Create
  m_SaggingOn = (sagging_opt_value != "" && sagging_opt_value != "off")? true: false;
 
  m_distanceCalcImpl = LArWheelCalculator_Impl::DistanceCalculatorFactory::Create(
                                          sagging_opt_value, this);
  if (m_SaggingOn) {
    msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOn = "  << this
        << ',' << m_distanceCalcImpl << endmsg;
  } else {
    msg << MSG::VERBOSE << "Creating DistanceCalculatorSaggingOff = " << this
        << ',' << m_distanceCalcImpl << endmsg;
  }
 
  m_fanCalcImpl = LArWheelCalculator_Impl::FanCalculatorFactory::Create(
      m_SaggingOn, m_isModule, this);
 
  //--------------------------
  // At this place there was the loading of sagging parameters
  // Transfered to DistanceCalculatorSaggingOn
  //--------------------------
 
  // Get option: Slant params.
  msg << MSG::VERBOSE << "Loading SlantAngle parameters ...";
  std::string slant_params;
 
  if (m_isInner) {
    slant_params=emecData.emecparams[0].INNERSLANTPARAM;
  } else {
    slant_params=emecData.emecparams[0].OUTERSLANTPARAM;
  }
 
  msg << (m_isInner?" InnerWheel ":" OuterWheel ") << slant_params << endmsg;
 
  if(slant_params != "" && slant_params != "default"){
    double a, b, c, d, e;
    if(sscanf(slant_params.c_str(), "%80le %80le %80le %80le %80le", &a, &b, &c, &d, &e) != 5){
      msg << MSG::ERROR
          << "LArWheelCalculator: ERROR: wrong value(s) "
          << "for EMEC slant angle parameters: "
          << slant_params << ", "
          << "defaults are used" << endmsg;
    } else {
      m_slant_parametrization[0] = a;
      m_slant_parametrization[1] = b;
      m_slant_parametrization[2] = c;
      m_slant_parametrization[3] = d;
      m_slant_parametrization[4] = e;
      m_slant_use_default = false;
    }
  } // else already initialized in inner/outer_wheel_init()
 
  fill_sincos_parameterization(); // initialize sin&cos parameterization
 
  msg << MSG::VERBOSE << "All params initialized. Print some internal variables" << endmsg;
 
  msg << MSG::VERBOSE << "Data members:" << endmsg 
      << "m_AtlasZside              = " << m_AtlasZside << "" << endmsg
      << "m_NumberOfFans            = " << m_NumberOfFans << "" << endmsg
      << "m_ZeroFanPhi              = " << m_ZeroFanPhi << "" << endmsg
      << "m_ZeroFanPhi_ForDetNeaFan = " << m_ZeroFanPhi_ForDetNeaFan << "" << endmsg
      << "m_FanStepOnPhi            = " << m_FanStepOnPhi << "" << endmsg
      << "m_FanHalfThickness        = " << m_FanHalfThickness << "" << endmsg
      //<< "Sagging parameters        : " << m_sagging_parameter[0][0] << " " << m_sagging_parameter[0][1] << "" << endmsg
      //<< "Sagging parameters        : " << m_sagging_parameter[1][0] << " " << m_sagging_parameter[1][1] << "" << endmsg
      << "slant_params              = " << slant_params << "" << endmsg
      << "Sagging option            = " << sagging_opt_value << "" << endmsg
      << "SaggingOn                 = " << (m_SaggingOn? "true": "false") << "" << endmsg
      << "Slant parameters          : ";
  for(int i = 0; i < 5; i ++) msg << " " << m_slant_parametrization[i];
  msg << endmsg;
 
  if(m_isModule){
    msg << MSG::VERBOSE
        << "module_init: FirstFan = " << m_FirstFan
        << ", LastFan = " << m_LastFan
        << ", ZeroFanPhi = " << m_ZeroFanPhi
        << endmsg;
  }
 
  //m_fan_number = -1000;
 
  // Is the following code fragment obsoleted? DM 2015-03-13
  /* to compare various methods of slant angle computation:
     if(isInner) return;
     FILE *O = fopen("slant_stat.table1.txt", "w");
     if(O == 0) abort();
     struct timeval t1, t2;
     struct timezone tz;
     std::vector<double> alpha;
     gettimeofday(&t1, &tz);
     for(double r = 600.; r < 2100.; r += .01){
     alpha.push_back(parameterized_slant_angle(r));
     }
     gettimeofday(&t2, &tz);
 
     fprintf(O, "%d.%06d %d.%06d" << endmsg, t1.tv_sec, t1.tv_usec, t2.tv_sec, t2.tv_usec);
     int i = 0;
     for(double r = 600.; r < 2100.; r += .01, i ++){
     fprintf(O, "%f %f\n", r, alpha[i]);
     }
 
     fclose(O);
     exit(0);
  */
}

◆ ~LArWheelCalculator()

LArWheelCalculator::~LArWheelCalculator ( )

virtual

Definition at line 92 of file LArWheelCalculator.cxx.

                                        {
  delete m_distanceCalcImpl;
  m_distanceCalcImpl = 0;
  delete m_fanCalcImpl;
  m_fanCalcImpl = 0;
}

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

                                                {
      int res_fan_number = fan_number;
      if(res_fan_number < 0) res_fan_number += m_NumberOfFans;
      res_fan_number += m_ZeroGapNumber;
      if(res_fan_number >= m_NumberOfFans) res_fan_number -= m_NumberOfFans;
      return res_fan_number;
    }

◆ AmplitudeOfSurface()

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

Definition at line 130 of file LArWheelCalculatorGeometry.cxx.

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

◆ 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.

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

◆ 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.

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

◆ fill_sincos_parameterization()

void LArWheelCalculator::fill_sincos_parameterization ( )

private

Definition at line 247 of file sincos_poly.cxx.

{
  // The polynomial approximations are calculated once per side, and stored
  // as statics for reuse in successive calculator instances.
  const sincos_params& p = m_isInner ? inner_params(*this) : outer_params(*this);
 
  // Fill the parameters into our instances variables
  m_sin_parametrization = p.sin;
  m_cos_parametrization = p.cos;
 
  // Parameterization for the vectorized sincos calculation
  // see ATLASSIM-4753 for details
  // s4, s5, c4, c5
  // s2, s3, c2, c3
  // s0, s1, c0, c1
  m_vsincos_par.param_0[0] = m_sin_parametrization[4];
  m_vsincos_par.param_0[1] = m_sin_parametrization[5];
  m_vsincos_par.param_0[2] = m_cos_parametrization[4];
  m_vsincos_par.param_0[3] = m_cos_parametrization[5];
  m_vsincos_par.param_1[0] = m_sin_parametrization[2];
  m_vsincos_par.param_1[1] = m_sin_parametrization[3];
  m_vsincos_par.param_1[2] = m_cos_parametrization[2];
  m_vsincos_par.param_1[3] = m_cos_parametrization[3];
  m_vsincos_par.param_2[0] = m_sin_parametrization[0];
  m_vsincos_par.param_2[1] = m_sin_parametrization[1];
  m_vsincos_par.param_2[2] = m_cos_parametrization[0];
  m_vsincos_par.param_2[3] = m_cos_parametrization[1];
}

◆ GetActiveLength()

double LArWheelCalculator::GetActiveLength ( ) const

inline

Definition at line 93 of file LArWheelCalculator.h.

93{ return m_ActiveLength; }

◆ GetAtlasZside()

int LArWheelCalculator::GetAtlasZside ( ) const

inline

Definition at line 85 of file LArWheelCalculator.h.

85{ return m_AtlasZside; }

◆ GetdWRPtoFrontFace()

double LArWheelCalculator::GetdWRPtoFrontFace ( ) const

inline

Definition at line 80 of file LArWheelCalculator.h.

80{ return m_dWRPtoFrontFace; }

◆ GetElecFocaltoWRP()

double LArWheelCalculator::GetElecFocaltoWRP ( ) const

inline

Definition at line 111 of file LArWheelCalculator.h.

111{ return m_dElecFocaltoWRP; }

◆ GetFanFoldRadius()

double LArWheelCalculator::GetFanFoldRadius ( ) const

inline

Definition at line 87 of file LArWheelCalculator.h.

87{ return m_FanFoldRadius; }

LArWheelCalculator::m_FanFoldRadius

double m_FanFoldRadius

Definition LArWheelCalculator.h:173

◆ GetFanHalfThickness() [1/2]

double LArWheelCalculator::GetFanHalfThickness ( ) const

inline

Definition at line 98 of file LArWheelCalculator.h.

98{ return m_FanHalfThickness; }

◆ GetFanHalfThickness() [2/2]

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

Definition at line 439 of file LArWheelCalculator.cxx.

{
 
  switch(t){
    case LArG4::BackInnerBarretteWheelCalib:
    case LArG4::BackInnerBarretteModuleCalib:
    case LArG4::BackInnerBarretteWheel:
    case LArG4::BackInnerBarretteModule:
    case LArG4::InnerAbsorberWheel:
    case LArG4::InnerAbsorberModule:
       return (m_leadThicknessInner / 2 + m_steelThickness + m_glueThickness)*m_coldContraction; // new values, 02.11.06 J.T. with contraction in cold
      // lead / 2 + steel + glue
    case LArG4::InnerGlueWheel:
      return (m_leadThicknessInner / 2 + m_glueThickness)*m_coldContraction;
    case LArG4::InnerLeadWheel:
      return m_leadThicknessInner / 2 * m_coldContraction;
 
    case LArG4::BackOuterBarretteWheelCalib:
    case LArG4::BackOuterBarretteModuleCalib:
    case LArG4::BackOuterBarretteWheel:
    case LArG4::BackOuterBarretteModule:
    case LArG4::OuterAbsorberWheel:
    case LArG4::OuterAbsorberModule:
       return (m_leadThicknessOuter / 2 + m_steelThickness + m_glueThickness)*m_coldContraction;  // new values, 02.11.06 J.T.
    case LArG4::OuterGlueWheel:
      return (m_leadThicknessOuter / 2 + m_glueThickness)*m_coldContraction;
    case LArG4::OuterLeadWheel:
      return m_leadThicknessOuter / 2 * m_coldContraction;
 
    case LArG4::InnerElectrodWheel:
    case LArG4::OuterElectrodWheel:
    case LArG4::InnerElectrodModule:
    case LArG4::OuterElectrodModule:
      return m_electrodeTotalThickness/m_electrodeInvContraction * 0.5;  //new values, 02.11.06 J.T
  }
  throw std::runtime_error("LArWheelCalculator::GetFanHalfThickness: wrong wheel type");
}

◆ GetFanStepOnPhi()

double LArWheelCalculator::GetFanStepOnPhi ( ) const

inline

Definition at line 94 of file LArWheelCalculator.h.

94{ return m_FanStepOnPhi; }

◆ GetFirstFan()

int LArWheelCalculator::GetFirstFan ( ) const

inline

Definition at line 114 of file LArWheelCalculator.h.

114{ return m_FirstFan; }

◆ GetHalfWaveLength()

double LArWheelCalculator::GetHalfWaveLength ( ) const

inline

Definition at line 95 of file LArWheelCalculator.h.

95{ return m_HalfWaveLength; }

◆ GetisBarrette()

bool LArWheelCalculator::GetisBarrette ( ) const

inline

Definition at line 103 of file LArWheelCalculator.h.

103{ return m_isBarrette; }

◆ GetisBarretteCalib()

bool LArWheelCalculator::GetisBarretteCalib ( ) const

inline

Definition at line 104 of file LArWheelCalculator.h.

104{ return m_isBarretteCalib; }

◆ GetisElectrode()

bool LArWheelCalculator::GetisElectrode ( ) const

inline

Definition at line 101 of file LArWheelCalculator.h.

101{ return m_isElectrode; }

◆ GetisInner()

bool LArWheelCalculator::GetisInner ( ) const

inline

Definition at line 102 of file LArWheelCalculator.h.

102{ return m_isInner; }

◆ GetisModule()

bool LArWheelCalculator::GetisModule ( ) const

inline

Definition at line 100 of file LArWheelCalculator.h.

100{ return m_isModule; }

◆ GetLastFan()

int LArWheelCalculator::GetLastFan ( ) const

inline

Definition at line 115 of file LArWheelCalculator.h.

115{ return m_LastFan; }

◆ GetNumberOfFans()

int LArWheelCalculator::GetNumberOfFans ( ) const

inline

Definition at line 91 of file LArWheelCalculator.h.

91{ return m_NumberOfFans; }

◆ GetNumberOfHalfWaves()

int LArWheelCalculator::GetNumberOfHalfWaves ( ) const

inline

Definition at line 90 of file LArWheelCalculator.h.

90{ return m_NumberOfHalfWaves; }

◆ GetNumberOfWaves()

int LArWheelCalculator::GetNumberOfWaves ( ) const

inline

Definition at line 89 of file LArWheelCalculator.h.

89{ return m_NumberOfWaves; }

◆ GetPhiGap()

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

inline

Definition at line 137 of file LArWheelCalculator.h.

137{ return GetPhiGapAndSide(p).first; }

LArWheelCalculator::GetPhiGapAndSide

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

Definition LArWheelCalculatorGeometry.cxx:98

◆ GetPhiGapAndSide()

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

Definition at line 98 of file LArWheelCalculatorGeometry.cxx.

{
  return m_fanCalcImpl->GetPhiGapAndSide(p);
}

◆ GetQuarterWaveLength()

double LArWheelCalculator::GetQuarterWaveLength ( ) const

inline

Definition at line 96 of file LArWheelCalculator.h.

96{ return m_QuarterWaveLength; }

◆ GetStartGapNumber()

int LArWheelCalculator::GetStartGapNumber ( ) const

inline

Definition at line 117 of file LArWheelCalculator.h.

117{ return m_ZeroGapNumber; }

◆ GetStraightStartSection()

double LArWheelCalculator::GetStraightStartSection ( ) const

inline

Definition at line 81 of file LArWheelCalculator.h.

81{ return m_StraightStartSection; }

◆ GetWheelInnerRadius() [1/2]

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

Definition at line 491 of file LArWheelCalculator.cxx.

{
  double zMid = 0.;
  if(m_isInner){
    double tanThetaInner = 2. * exp(-m_eta_hi ) / (1. - exp(-2.*m_eta_hi ));
    r[0] = m_zWheelFrontFace * tanThetaInner;
    r[1] = m_zWheelBackFace  * tanThetaInner;
  }
  return zMid;
}

◆ GetWheelInnerRadius() [2/2]

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

Definition at line 502 of file LArWheelCalculator.cxx.

{
  double zMid = 0.;
  if (not m_isInner){
    double tanThetaMid   = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
    double inv_tanThetaOuter = (1. - exp(-2.*m_eta_low)) / (2. * exp(-m_eta_low));
    // Note that there is a 3mm gap between the outer surface of the
    // inner wheel and the inner surface of the outer wheel.
    r[0] = m_zWheelFrontFace * tanThetaMid + m_HalfGapBetweenWheels;
    r[1] = m_rOuterCutoff * inv_tanThetaOuter * tanThetaMid + m_HalfGapBetweenWheels;
    r[2] = m_zWheelBackFace  * tanThetaMid + m_HalfGapBetweenWheels;
    zMid = m_rOuterCutoff * inv_tanThetaOuter - m_zWheelFrontFace;
  }
  return zMid;
}

◆ GetWheelOuterRadius() [1/2]

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

Definition at line 523 of file LArWheelCalculator.cxx.

{
  if(m_isInner){
    double tanThetaMid   = 2. * exp(-m_eta_mid) / (1. - exp(-2.*m_eta_mid));
    // Note that there is a 3mm gap between the outer surface of the
    // inner wheel and the inner surface of the outer wheel.
    r[0] = m_zWheelFrontFace * tanThetaMid - m_HalfGapBetweenWheels;
    r[1] = m_zWheelBackFace  * tanThetaMid - m_HalfGapBetweenWheels;
  }
}

◆ GetWheelOuterRadius() [2/2]

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

Definition at line 533 of file LArWheelCalculator.cxx.

{
  if(not m_isInner){
    double tanThetaOuter = 2. * exp(-m_eta_low) / (1. - exp(-2.*m_eta_low));
    r[0] = m_zWheelFrontFace * tanThetaOuter;
    r[1] = m_rOuterCutoff;
    r[2] = m_rOuterCutoff;
  }
}

◆ GetWheelRefPoint()

double LArWheelCalculator::GetWheelRefPoint ( ) const

inline

Definition at line 97 of file LArWheelCalculator.h.

97{ return m_zWheelRefPoint; }

◆ GetWheelThickness()

double LArWheelCalculator::GetWheelThickness ( ) const

inline

Definition at line 79 of file LArWheelCalculator.h.

79{ return m_WheelThickness; }

◆ GetZeroFanPhi()

double LArWheelCalculator::GetZeroFanPhi ( ) const

inline

Definition at line 88 of file LArWheelCalculator.h.

88{ return m_ZeroFanPhi; }

◆ inner_wheel_init()

void LArWheelCalculator::inner_wheel_init ( const EMECData & emecData )

private

Definition at line 406 of file LArWheelCalculator.cxx.

{
  for(int i = 0; i < 5; ++ i) {
    m_slant_parametrization[i] = default_slant_parametrization[0][i];
  }
  m_slant_use_default = true;
 
  m_NumberOfFans=emecData.emecwheelparameters[0].NABS;
  m_NumberOfWaves=emecData.emecwheelparameters[0].NACC;
 
  m_FanFoldRadius = 3.25*mm;
  m_ZeroGapNumber = 64; // internal constant, should not be taken from DB
  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
  m_isInner = true;
}

◆ LArWheelCalculatorTypeString()

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

static

Definition at line 65 of file LArWheelCalculator.cxx.

{
  switch(type){
     case LArG4::InnerAbsorberWheel:           return("InnerAbsorberWheel");
     case LArG4::OuterAbsorberWheel:           return("OuterAbsorberWheel");
     case LArG4::InnerElectrodWheel:           return("InnerElectrodWheel");
     case LArG4::OuterElectrodWheel:           return("OuterElectrodWheel");
     case LArG4::InnerAbsorberModule:          return("InnerAbsorberModule");
     case LArG4::OuterAbsorberModule:          return("OuterAbsorberModule");
     case LArG4::InnerElectrodModule:          return("InnerElectrodModule");
     case LArG4::OuterElectrodModule:          return("OuterElectrodModule");
     case LArG4::BackOuterBarretteWheel:       return("BackOuterBarretteWheel");
     case LArG4::BackInnerBarretteWheel:       return("BackInnerBarretteWheel");
     case LArG4::BackOuterBarretteModule:      return("BackOuterBarretteModule");
     case LArG4::BackInnerBarretteModule:      return("BackInnerBarretteModule");
     case LArG4::BackOuterBarretteWheelCalib:  return("BackOuterBarretteWheelCalib");
     case LArG4::BackInnerBarretteWheelCalib:  return("BackInnerBarretteWheelCalib");
     case LArG4::BackOuterBarretteModuleCalib: return("BackOuterBarretteModuleCalib");
     case LArG4::BackInnerBarretteModuleCalib: return("BackInnerBarretteModuleCalib");
     case LArG4::InnerGlueWheel:               return("InnerGlueWheel");
     case LArG4::InnerLeadWheel:               return("InnerLeadWheel");
     case LArG4::OuterGlueWheel:               return("OuterGlueWheel");
     case LArG4::OuterLeadWheel:               return("OuterLeadWheel");
  }
  return("unknown");
}

◆ module_init()

void LArWheelCalculator::module_init ( )

private

Definition at line 477 of file LArWheelCalculator.cxx.

{
  m_isModule = true;
  m_LastFan = m_NumberOfFans / 8;
  m_FirstFan = 0;
  m_ZeroFanPhi = - m_LastFan / 2 * m_FanStepOnPhi;
}

◆ NearestPointOnNeutralFibre()

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

Definition at line 113 of file LArWheelCalculatorGeometry.cxx.

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

◆ NearestPointOnNeutralFibre_asVector()

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

Definition at line 118 of file LArWheelCalculatorGeometry.cxx.

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

◆ operator=()

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

delete

◆ outer_wheel_init()

void LArWheelCalculator::outer_wheel_init ( const EMECData & emecData )

private

Definition at line 422 of file LArWheelCalculator.cxx.

{
  for(int i = 0; i < 5; ++ i) {
    m_slant_parametrization[i] = default_slant_parametrization[1][i];
  }
  m_slant_use_default = true;
 
  m_NumberOfFans=emecData.emecwheelparameters[1].NABS;
  m_NumberOfWaves=emecData.emecwheelparameters[1].NACC;
 
 
  m_FanFoldRadius = 3.0*mm;
  m_ZeroGapNumber = 192; // internal constant, should not be taken from DB
  m_FanStepOnPhi = 2*M_PI / m_NumberOfFans;
  m_isInner = false;
}

◆ 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.

{
  const double r2 = r*r;
  const double r3 = r2*r;
  const double r4 = r2*r2;
#if LARWC_SINCOS_POLY > 4
  const double r5 = r4*r;
#endif
  sin_a = m_sin_parametrization[0]
        + m_sin_parametrization[1]*r
        + m_sin_parametrization[2]*r2
        + m_sin_parametrization[3]*r3
        + m_sin_parametrization[4]*r4
#if LARWC_SINCOS_POLY > 4
        + m_sin_parametrization[5]*r5
#endif
  ;
  cos_a = sqrt(1. - sin_a*sin_a);
}

◆ 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.

{
  const double r2 = r*r;
  const double r3 = r2*r;
  const double r4 = r2*r2;
#if LARWC_SINCOS_POLY > 4
  const double r5 = r4*r;
#endif
  sin_a = m_sin_parametrization[0]
        + m_sin_parametrization[1]*r
        + m_sin_parametrization[2]*r2
        + m_sin_parametrization[3]*r3
        + m_sin_parametrization[4]*r4
#if LARWC_SINCOS_POLY > 4
        + m_sin_parametrization[5]*r5
#endif
  ;
  cos_a = m_cos_parametrization[0]
        + m_cos_parametrization[1]*r
        + m_cos_parametrization[2]*r2
        + m_cos_parametrization[3]*r3
        + m_cos_parametrization[4]*r4
#if LARWC_SINCOS_POLY > 4
        + m_cos_parametrization[5]*r5
#endif
  ;
}

◆ 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.

{
  const double r2 = r*r;
  const double r3 = r2*r;
  const double r4 = r2*r2;
  const double result = m_slant_parametrization[0] +
                        r*m_slant_parametrization[1] +
                        r2*m_slant_parametrization[2] +
                        r3*m_slant_parametrization[3] +
                        r4*m_slant_parametrization[4];
  return result*deg;
}

◆ PhiGapNumberForWheel()

int LArWheelCalculator::PhiGapNumberForWheel ( int i ) const

Definition at line 401 of file LArWheelCalculator.cxx.

{
  return m_fanCalcImpl->PhiGapNumberForWheel(i);
}

◆ SetStartGapNumber()

void LArWheelCalculator::SetStartGapNumber ( int n )

inline

Definition at line 118 of file LArWheelCalculator.h.

118{ m_ZeroGapNumber = n; }

beamspotman.n

n

Definition beamspotman.py:727

◆ type()

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

inlinevirtual

Definition at line 82 of file LArWheelCalculator.h.

82{ return m_type; }

◆ zShift()

double LArWheelCalculator::zShift ( ) const

inline

Definition at line 86 of file LArWheelCalculator.h.

86{ return m_zShift; }

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOff

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOff

friend

Definition at line 61 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOn

friend class LArWheelCalculator_Impl::DistanceCalculatorSaggingOn

friend

Definition at line 62 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan

template<typename SaggingType>

friend class LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan

friend

Definition at line 65 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::ModuleFanCalculator

friend class LArWheelCalculator_Impl::ModuleFanCalculator

friend

Definition at line 63 of file LArWheelCalculator.h.

◆ LArWheelCalculator_Impl::WheelFanCalculator

template<typename SaggingType>

friend class LArWheelCalculator_Impl::WheelFanCalculator

friend

Definition at line 64 of file LArWheelCalculator.h.

Member Data Documentation

◆ m_ActiveLength

double LArWheelCalculator::m_ActiveLength

private

Definition at line 156 of file LArWheelCalculator.h.

◆ m_AtlasZside

int LArWheelCalculator::m_AtlasZside

private

Definition at line 147 of file LArWheelCalculator.h.

◆ m_coldContraction

double LArWheelCalculator::m_coldContraction

private

Definition at line 198 of file LArWheelCalculator.h.

◆ m_cos_parametrization

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

private

Definition at line 153 of file LArWheelCalculator.h.

◆ m_dElecFocaltoWRP

double LArWheelCalculator::m_dElecFocaltoWRP

private

Definition at line 162 of file LArWheelCalculator.h.

◆ m_distanceCalcImpl

LArWheelCalculator_Impl::IDistanceCalculator* LArWheelCalculator::m_distanceCalcImpl

private

Definition at line 236 of file LArWheelCalculator.h.

◆ m_dMechFocaltoWRP

double LArWheelCalculator::m_dMechFocaltoWRP

private

Definition at line 161 of file LArWheelCalculator.h.

◆ m_dWRPtoFrontFace

double LArWheelCalculator::m_dWRPtoFrontFace

private

Definition at line 158 of file LArWheelCalculator.h.

◆ m_electrodeInvContraction

double LArWheelCalculator::m_electrodeInvContraction

private

Definition at line 199 of file LArWheelCalculator.h.

◆ m_electrodeTotalThickness

double LArWheelCalculator::m_electrodeTotalThickness

private

Definition at line 197 of file LArWheelCalculator.h.

◆ m_eta_hi

double LArWheelCalculator::m_eta_hi

private

Definition at line 164 of file LArWheelCalculator.h.

◆ m_eta_low

double LArWheelCalculator::m_eta_low

private

Definition at line 164 of file LArWheelCalculator.h.

◆ m_eta_mid

double LArWheelCalculator::m_eta_mid

private

Definition at line 164 of file LArWheelCalculator.h.

◆ m_fanCalcImpl

LArWheelCalculator_Impl::IFanCalculator* LArWheelCalculator::m_fanCalcImpl

private

Definition at line 237 of file LArWheelCalculator.h.

◆ m_FanFoldRadius

double LArWheelCalculator::m_FanFoldRadius

private

Definition at line 173 of file LArWheelCalculator.h.

◆ m_FanHalfThickness

double LArWheelCalculator::m_FanHalfThickness

private

Definition at line 181 of file LArWheelCalculator.h.

◆ m_FanStepOnPhi

double LArWheelCalculator::m_FanStepOnPhi

private

Definition at line 176 of file LArWheelCalculator.h.

◆ m_FirstFan

int LArWheelCalculator::m_FirstFan

private

Definition at line 183 of file LArWheelCalculator.h.

◆ m_glueThickness

double LArWheelCalculator::m_glueThickness

private

Definition at line 196 of file LArWheelCalculator.h.

◆ m_HalfGapBetweenWheels

double LArWheelCalculator::m_HalfGapBetweenWheels

private

Definition at line 159 of file LArWheelCalculator.h.

◆ m_HalfWaveLength

double LArWheelCalculator::m_HalfWaveLength

private

Definition at line 172 of file LArWheelCalculator.h.

◆ m_HalfWheelThickness

double LArWheelCalculator::m_HalfWheelThickness

private

Definition at line 168 of file LArWheelCalculator.h.

◆ m_isBarrette

bool LArWheelCalculator::m_isBarrette

private

Definition at line 189 of file LArWheelCalculator.h.

◆ m_isBarretteCalib

bool LArWheelCalculator::m_isBarretteCalib

private

Definition at line 190 of file LArWheelCalculator.h.

◆ m_isElectrode

bool LArWheelCalculator::m_isElectrode

private

Definition at line 187 of file LArWheelCalculator.h.

◆ m_isInner

bool LArWheelCalculator::m_isInner

private

Definition at line 188 of file LArWheelCalculator.h.

◆ m_isModule

bool LArWheelCalculator::m_isModule

private

Definition at line 186 of file LArWheelCalculator.h.

◆ m_LastFan

int LArWheelCalculator::m_LastFan

private

Definition at line 184 of file LArWheelCalculator.h.

◆ m_leadThicknessInner

double LArWheelCalculator::m_leadThicknessInner

private

Definition at line 193 of file LArWheelCalculator.h.

◆ m_leadThicknessOuter

double LArWheelCalculator::m_leadThicknessOuter

private

Definition at line 194 of file LArWheelCalculator.h.

◆ m_NumberOfFans

int LArWheelCalculator::m_NumberOfFans

private

Definition at line 179 of file LArWheelCalculator.h.

◆ m_NumberOfHalfWaves

int LArWheelCalculator::m_NumberOfHalfWaves

private

Definition at line 178 of file LArWheelCalculator.h.

◆ m_NumberOfWaves

int LArWheelCalculator::m_NumberOfWaves

private

Definition at line 177 of file LArWheelCalculator.h.

◆ m_phiRotation

bool LArWheelCalculator::m_phiRotation

private

Definition at line 149 of file LArWheelCalculator.h.

◆ m_QuarterWaveLength

double LArWheelCalculator::m_QuarterWaveLength

private

Definition at line 171 of file LArWheelCalculator.h.

◆ m_rOuterCutoff

double LArWheelCalculator::m_rOuterCutoff

private

Definition at line 163 of file LArWheelCalculator.h.

◆ m_sagging_parameter

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

private

Definition at line 154 of file LArWheelCalculator.h.

◆ m_SaggingOn

bool LArWheelCalculator::m_SaggingOn

private

Definition at line 148 of file LArWheelCalculator.h.

◆ m_sin_parametrization

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

private

Definition at line 152 of file LArWheelCalculator.h.

◆ m_slant_parametrization

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

private

Definition at line 151 of file LArWheelCalculator.h.

◆ m_slant_use_default

bool LArWheelCalculator::m_slant_use_default

private

Definition at line 150 of file LArWheelCalculator.h.

◆ m_steelThickness

double LArWheelCalculator::m_steelThickness

private

Definition at line 195 of file LArWheelCalculator.h.

◆ m_StraightStartSection

double LArWheelCalculator::m_StraightStartSection

private

Definition at line 157 of file LArWheelCalculator.h.

◆ m_type

LArG4::LArWheelCalculator_t LArWheelCalculator::m_type

private

Definition at line 145 of file LArWheelCalculator.h.

◆ m_WheelThickness

double LArWheelCalculator::m_WheelThickness

private

Definition at line 167 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi

double LArWheelCalculator::m_ZeroFanPhi

private

Definition at line 174 of file LArWheelCalculator.h.

◆ m_ZeroFanPhi_ForDetNeaFan

double LArWheelCalculator::m_ZeroFanPhi_ForDetNeaFan

private

Definition at line 175 of file LArWheelCalculator.h.

◆ m_ZeroGapNumber

int LArWheelCalculator::m_ZeroGapNumber

private

Definition at line 182 of file LArWheelCalculator.h.

◆ m_zShift

double LArWheelCalculator::m_zShift

private

Definition at line 165 of file LArWheelCalculator.h.

◆ m_zWheelBackFace

double LArWheelCalculator::m_zWheelBackFace

private

Definition at line 169 of file LArWheelCalculator.h.

◆ m_zWheelFrontFace

double LArWheelCalculator::m_zWheelFrontFace

private

Definition at line 169 of file LArWheelCalculator.h.

◆ m_zWheelRefPoint

double LArWheelCalculator::m_zWheelRefPoint

private

Definition at line 160 of file LArWheelCalculator.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ LArWheelCalculator() [1/2]

◆ ~LArWheelCalculator()

◆ LArWheelCalculator() [2/2]

Member Function Documentation

◆ adjust_fan_number()

◆ AmplitudeOfSurface()

◆ DistanceToTheNearestFan()

◆ DistanceToTheNeutralFibre()

◆ fill_sincos_parameterization()

◆ GetActiveLength()

◆ GetAtlasZside()

◆ GetdWRPtoFrontFace()

◆ GetElecFocaltoWRP()

◆ GetFanFoldRadius()

◆ GetFanHalfThickness() [1/2]

◆ GetFanHalfThickness() [2/2]

◆ GetFanStepOnPhi()

◆ GetFirstFan()

◆ GetHalfWaveLength()

◆ GetisBarrette()

◆ GetisBarretteCalib()

◆ GetisElectrode()

◆ GetisInner()

◆ GetisModule()

◆ GetLastFan()

◆ GetNumberOfFans()

◆ GetNumberOfHalfWaves()

◆ GetNumberOfWaves()

◆ GetPhiGap()

◆ GetPhiGapAndSide()

◆ GetQuarterWaveLength()

◆ GetStartGapNumber()

◆ GetStraightStartSection()

◆ GetWheelInnerRadius() [1/2]

◆ GetWheelInnerRadius() [2/2]

◆ GetWheelOuterRadius() [1/2]

◆ GetWheelOuterRadius() [2/2]

◆ GetWheelRefPoint()

◆ GetWheelThickness()

◆ GetZeroFanPhi()

◆ inner_wheel_init()

◆ LArWheelCalculatorTypeString()

◆ module_init()

◆ NearestPointOnNeutralFibre()

◆ NearestPointOnNeutralFibre_asVector()

◆ operator=()

◆ outer_wheel_init()

◆ parameterized_sin()

◆ parameterized_sincos()

◆ parameterized_slant_angle()

◆ PhiGapNumberForWheel()

◆ SetStartGapNumber()

◆ type()

◆ zShift()

Friends And Related Symbol Documentation

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOff

◆ LArWheelCalculator_Impl::DistanceCalculatorSaggingOn

◆ LArWheelCalculator_Impl::DistanceToTheNeutralFibre_OfFan

◆ LArWheelCalculator_Impl::ModuleFanCalculator

◆ LArWheelCalculator_Impl::WheelFanCalculator

Member Data Documentation

◆ m_ActiveLength

◆ m_AtlasZside

◆ m_coldContraction

◆ m_cos_parametrization

◆ m_dElecFocaltoWRP

◆ m_distanceCalcImpl

◆ m_dMechFocaltoWRP

◆ m_dWRPtoFrontFace

◆ m_electrodeInvContraction

◆ m_electrodeTotalThickness

◆ m_eta_hi

◆ m_eta_low