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.
const LArWheelCalculator *	lwc () const
	Return the calculator:
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.

    : parent(lwc),
      m_saggingOptions(saggingOptions)
 
  {
    init_sagging_parameters();
  }

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 127 of file DistanceCalculatorSaggingOn.cxx.

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

DistanceToTheNeutralFibre()

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

virtual

Reimplemented from LArWheelCalculator_Impl::DistanceCalculatorSaggingOff.

Definition at line 117 of file DistanceCalculatorSaggingOn.cxx.

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

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.

  {
    double z = P.z() - lwc()->m_StraightStartSection;
    double x = P.x();
 
#ifdef LWC_PARAM_ANGLE //old variant
    const double alpha = lwc()->parameterized_slant_angle(P.y());
    CxxUtils::sincos scalpha(alpha);
    double cos_a = scalpha.cs, sin_a = scalpha.sn;
#else // parameterized sine
    double cos_a, sin_a;
    lwc()->m_vsincos_par.eval(P.y(), sin_a, cos_a);
#endif
 
    bool sqw = false;
    if(z > lwc()->m_QuarterWaveLength){
      if(z < m_EndQuarterWave){ // regular half-waves
        unsigned int nhwave = (unsigned int)(z / lwc()->m_HalfWaveLength + 0.5);
        z -= lwc()->m_HalfWaveLength * nhwave;
        const double straight_part = (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
        nhwave &= 1U;
        if(nhwave == 0) sin_a = - sin_a;
        double z_prime = z * cos_a + x * sin_a;
        const double x_prime = z * sin_a - x * cos_a;
        if(z_prime > straight_part){ // up fold region
          const double dz = z_prime - straight_part;
          if(nhwave == 0){
            const double dx = x_prime + lwc()->m_FanFoldRadius;
            return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
          } else {
            const double dx = x_prime - lwc()->m_FanFoldRadius;
            return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
          }
        }
        z_prime += straight_part;
        if(z_prime > 0){
          return x_prime; // straight part of the quarter-wave
        } else { // low fold region
          const double &dz = z_prime;
          if(nhwave == 0){
            const double dx = x_prime - lwc()->m_FanFoldRadius;
            return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
          } else {
            const double dx = x_prime + lwc()->m_FanFoldRadius;
            return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
          }
        }
      } else { // ending quarter-wave
        z = lwc()->m_ActiveLength - z;
      }
    } else { // starting quarter-wave
      x = - x;
      sqw = true;
    }
 
    // start and finish quarter-waves
    const double tan_beta = sin_a/(1.0 + cos_a); //tan(alpha * 0.5);
    const double local_straight_section = lwc()->m_FanFoldRadius * tan_beta;
    if(z < - local_straight_section &&
       ( x < lwc()->m_FanFoldRadius ||
         x < - lwc()->m_StraightStartSection * z / local_straight_section / tan_beta ))
    {
      return sqw? x: (-x);
    }
    else {
      const double z_prime = z * cos_a + x * sin_a;
      const double x_prime = x * cos_a - z * sin_a;
      if (z_prime < local_straight_section) { // start fold region
        const double dz = local_straight_section - z_prime;
        const double dx = x_prime - lwc()->m_FanFoldRadius;
        if(sqw) return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
        else    return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
      } else {
        const double straight_part =
          (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
        if (z_prime <= straight_part) { // straight part of quarter-wave
          return sqw? x_prime: (-x_prime);
        } else { // regular fold region of the quarter-wave
          const double dz = straight_part - z_prime;
          const double dx = x_prime + lwc()->m_FanFoldRadius;
          if(sqw) return sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
          else    return lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
        }
      }
    }
    // ???
    std::abort();
  }

get_sagging()

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

private

Definition at line 133 of file DistanceCalculatorSaggingOn.cxx.

                                                                                                {
#ifdef HARDDEBUG
    std::cout << "get_sagging: MFN = " << fan_number << std::endl;
#endif
    double dx = P.z() / lwc()->m_HalfWheelThickness - 1.;
    dx *= dx;
    dx = 1. - dx;
    //dx *= SaggingAmplitude * sin(FanStepOnPhi * m_fan_number + ZeroFanPhi);
    //int n = m_fan_number;
    //if(n < 0) n += m_NumberOfFans;
    //n += m_ZeroGapNumber;
    //if(n >= m_NumberOfFans) n -= m_NumberOfFans;
    //const std::vector<double>& sp = m_sagging_parameter[n];
    const std::vector<double>& sp = m_sagging_parameter[fan_number];
    double R = P.r() / mm;
    double r = R;
    double result = sp[0];
    result += R * sp[1];
    R *= r;
    result += R * sp[2];
    R *= r;
    result += R * sp[3];
    R *= r;
    result += R * sp[4];
 
#ifdef HARDDEBUG
    /*printf("get_sagging: (%6.3f, %6.3f, %6.3f) %6.3f; MFN %4d;"
      "n %3d; sp %6.4f %6.4f; dx %6.3f; %.6f\n", P.x()/mm, P.y()/mm, P.z()/mm,
      r, m_fan_number, n, sp[0], sp[1], dx, result*dx);*/
    printf("get_sagging: (%6.3f, %6.3f, %6.3f) %6.3f;"
           " sp %6.4f %6.4f; dx %6.3f; %.6f\n", P.x()/mm, P.y()/mm, P.z()/mm,
           r, sp[0], sp[1], dx, result*dx);
#endif //HARDDEBUG
 
    return result * dx;
  }

init_sagging_parameters()

void LArWheelCalculator_Impl::DistanceCalculatorSaggingOn::init_sagging_parameters ( )

private

Definition at line 36 of file DistanceCalculatorSaggingOn.cxx.

  {
 
    // Get pointer to the message service
#ifndef PORTABLE_LAR_SHAPE
    SmartIF<IMessageSvc> msgSvc{Gaudi::svcLocator()->service("MessageSvc")};
    if(!msgSvc.isValid()) {
      throw std::runtime_error("LArWheelCalculator constructor: cannot initialze message service");
    }
    MsgStream msg(msgSvc, "LArWheelCalculator_Impl::DistanceCalculatorSaggingOn");
#else
    PortableMsgStream msg("LArWheelCalculator_Impl::DistanceCalculatorSaggingOn");
#endif
    std::string sagging_opt_value = m_saggingOptions;
    m_sagging_parameter.resize (lwc()->m_NumberOfFans, std::vector<double> (5, 0.));
    //  if(m_SaggingOn) {
    if(sagging_opt_value.substr(0, 4) == "file"){
      std::string sag_file = sagging_opt_value.substr(5);
      msg << MSG::DEBUG
        << "geting sagging parameters from file "
        << sag_file << " ..." << endmsg;
      FILE *F = fopen(sag_file.c_str(), "r");
      if(F == 0){
        msg << MSG::FATAL
          << "cannot open EMEC sagging parameters file "
          << sag_file
          << endmsg;
        throw std::runtime_error("LArWheelCalculator: read sagging parameters from file");
      }
      int s, w, t, n;
      double p0, p1, p2, p3, p4;
      while(!feof(F) &&
            fscanf(F, "%80d %80d %80d %80d %80le %80le %80le %80le %80le",
                   &s, &w, &t, &n, &p0, &p1, &p2, &p3, &p4) == 9)
      {
        if(s == lwc()->m_AtlasZside &&
           ((w == 0 && lwc()->m_isInner) || (w == 1 && !lwc()->m_isInner)) &&
           ((t == 0 && !lwc()->m_isElectrode) || (t == 1 && lwc()->m_isElectrode)) &&
           (n >= 0 && n < lwc()->m_NumberOfFans))
        {
          m_sagging_parameter[n][0] = p0;
          m_sagging_parameter[n][1] = p1;
          m_sagging_parameter[n][2] = p2;
          m_sagging_parameter[n][3] = p3;
          m_sagging_parameter[n][4] = p4;
          msg << MSG::VERBOSE
              << "sagging for " << s << " " << w << " " << t
              << " " << n << ": " << p0 << " " << p1 << " "
              << p2 << " " << p3 << endmsg;
        }
      }
      fclose(F);
    } else {
      double a, b, c, d;
      if(sscanf(sagging_opt_value.c_str(), "%80le %80le %80le %80le", &a, &b, &c, &d) != 4){
        msg << MSG::ERROR
            << "wrong value(s) "
            << " for EMEC sagging parameters: "
            << sagging_opt_value << ", defaults are used" << endmsg;
      } else {
        for(int j = 0; j < lwc()->m_NumberOfFans; j ++){
          if(lwc()->m_isInner){
            m_sagging_parameter[j][1] = a;
            m_sagging_parameter[j][0] = b * mm;
          } else {
            m_sagging_parameter[j][1] = c;
            m_sagging_parameter[j][0] = d * mm;
          }
        }
      }
    }
    //  }
    msg << MSG::INFO  << "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;
  }

lwc()

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

inlineinherited

Return the calculator:

Definition at line 38 of file DistanceCalculatorSaggingOff.h.

{ 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 122 of file DistanceCalculatorSaggingOn.cxx.

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

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.

  {
    CLHEP::Hep3Vector result;
    double z = P.z() - lwc()->m_StraightStartSection;
    double x = P.x();
    double y = P.y();
 
#ifdef LWC_PARAM_ANGLE //old variant
    const double alpha = lwc()->parameterized_slant_angle(P.y());
    CxxUtils::sincos scalpha(alpha);
    double cos_a = scalpha.cs, sin_a = scalpha.sn;
#else // parameterized sine
    double cos_a, sin_a;
    lwc()->m_vsincos_par.eval(P.y(), sin_a, cos_a);
#endif
 
    bool sqw = false;
    if(z > lwc()->m_QuarterWaveLength){
      if(z < m_EndQuarterWave){ // regular half-waves
        unsigned int nhwave = (unsigned int)(z / lwc()->m_HalfWaveLength + 0.5);
        const double zshift = lwc()->m_HalfWaveLength * nhwave;
        z -= zshift;
        const double straight_part =
          (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
        nhwave &= 1U;
        if(nhwave == 0) sin_a = - sin_a;
        const double z_prime = z * cos_a + x * sin_a;
        if(z_prime > straight_part){ // up fold
          const double x_prime = x * cos_a - z * sin_a;
          const double dz = straight_part - z_prime;
          double a1 = atan(fabs(dz / (x_prime + lwc()->m_FanFoldRadius)));
          const double x1 = lwc()->m_FanFoldRadius * (cos(a1) - 1.);
          const double z1 = straight_part + lwc()->m_FanFoldRadius * sin(a1);
          result.set(x1*cos_a - z1*sin_a, y, z1*cos_a + z1*sin_a);
          return result;
        } else if(z_prime > -straight_part){ // straight part
          result.set(-z_prime * sin_a, y, z_prime*cos_a + zshift);
          return result;
        } else { // low fold
          const double x_prime = x * cos_a - z * sin_a;
          const double dz = straight_part + z_prime;
          double a1 = atan(fabs(dz / (x_prime + lwc()->m_FanFoldRadius)));
          const double x1 = lwc()->m_FanFoldRadius * (cos(a1) - 1.);
          const double z1 = straight_part + lwc()->m_FanFoldRadius * sin(a1);
          result.set(x1*cos_a - z1*sin_a, y, z1*cos_a + z1*sin_a);
          return result;
        }
      } else { // ending quarter-wave
        z = lwc()->m_ActiveLength - z;
      }
    } else { // starting quarter-wave
      x = - x;
      sqw = true;
    }
 
    // start and finish quarter-waves
    const double tan_beta = sin_a / (1.0 + cos_a);
    const double local_straight_section = lwc()->m_FanFoldRadius * tan_beta;
    if(z < - local_straight_section &&
       (x < lwc()->m_FanFoldRadius ||
        x < - lwc()->m_StraightStartSection * z / local_straight_section / tan_beta))
    {
      result.set(0., y, z);
    }
    else {
      const double z_prime = z * cos_a + x * sin_a;
      const double x_prime = x * cos_a - z * sin_a;
      if(z_prime < local_straight_section) {
        double a = fabs(atan((local_straight_section - z_prime) / (x_prime - lwc()->m_FanFoldRadius)));
        result.set(lwc()->m_FanFoldRadius * (1 - cos(a)), y, local_straight_section - lwc()->m_FanFoldRadius * sin(a));
      } else {
        double straight_part = (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
        if(z_prime <= straight_part) {
          result.set(0., y, z_prime);
        } else {
          double a = fabs(atan((straight_part - z_prime) /  (x_prime + lwc()->m_FanFoldRadius)) );
          result.set(lwc()->m_FanFoldRadius * (cos(a) - 1), y, straight_part + lwc()->m_FanFoldRadius * sin(a));
        }
      }
      result.rotateY(asin(sin_a));
    }
    if(sqw) result.setX(-result.x());
    else result.setZ(lwc()->m_ActiveLength - result.z());
    result.setZ(result.z() + lwc()->m_StraightStartSection);
    return result;
  }

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:

• DistanceCalculatorSaggingOn.h
• DistanceCalculatorSaggingOn.cxx