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 28 of file DistanceCalculatorSaggingOff.cxx.

  {
    assert(P.y() > 0.);
    double distance = 0.;
    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());
    //double cos_a, sin_a;
    //::sincos(alpha, &sin_a, &cos_a);
    CxxUtils::sincos scalpha(alpha);
    const 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
    // determination of the nearest quarter-wave number
    int nqwave = (z < 0.) ? 0 : int(z / lwc()->m_QuarterWaveLength);
    //if(z < 0.) nqwave = 0;
    //else nqwave = int(z / lwc()->m_QuarterWaveLength);
 
    bool begin_qw = false;
    if((nqwave % 2) != 0){
      nqwave ++;
      begin_qw = true;
    }
 
    nqwave /= 2;
 
    // now nqwave is not the number of quarter-wave but the number of half-wave
    // half-waves with last and zero numbers are not really half-waves but start
    // and finish quarter-waves
    // It means that half-wave number 1 begins after starting quarter-wave
    if(nqwave != 0 && nqwave != lwc()->m_NumberOfHalfWaves){ // regular half-waves
      z -= nqwave * lwc()->m_HalfWaveLength;
      // there are some symmetries, so use them
      if((nqwave % 2) == 0) x = -x;
      if(begin_qw){
        z = -z;
        x = -x;
      }
      // certain situation: rising slope of wave, z is positive
      // rotate to prime-coordinate system (see description)
      const double z_prime = z * cos_a + x * sin_a;
      const double x_prime = x * cos_a - z * sin_a;
      const double straight_part = (lwc()->m_QuarterWaveLength - lwc()->m_FanFoldRadius * sin_a) / cos_a;
      if(z_prime > straight_part){// fold region
        const double dz = straight_part - z_prime;
        const double dx = x_prime + lwc()->m_FanFoldRadius;
        distance = sqrt(dz*dz + dx*dx) - lwc()->m_FanFoldRadius;
      } else if(z_prime > -straight_part){
        distance = x_prime; // straight part of the quarter-wave
      } else {// fold region
        const double dz = straight_part + z_prime;
        const double dx = x_prime - lwc()->m_FanFoldRadius;
        distance = lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
      }
      // set correct sign for result
      if(!begin_qw) distance = -distance;
      if((nqwave % 2) == 0) distance = -distance;
 
    } else { // start and finish quarter-waves
      if(nqwave == 0)   { // start quarter-wave
        x = - x;
      } else { // finish quarter-wave
        z = lwc()->m_ActiveLength - z;
      }
 
      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 ) )
      {
        distance = - 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;
          distance = 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
            distance = - 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;
            distance = lwc()->m_FanFoldRadius - sqrt(dz*dz + dx*dx);
          }
        }
      }
      // set correct sign
      if (nqwave == 0) distance = -distance;
    }
#ifdef HARDDEBUG
    double dd = DistanceToTheNeutralFibre_ref(P);
    if(fabs(dd - distance) > 0.000001){
      //static int cnt = 0;
      std::cout << "DTNF MISMATCH " << this << " " << P << " "
                << dd << " vs " << distance << std::endl;
      //cnt ++;
      //if(cnt > 100) exit(0);
    }
#endif
    return distance;
  }

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 317 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