LArWheelCalculator_Impl::WheelFanCalculator< SaggingType > Class Template Reference

LAr wheel fan calculator, templated for sagging settings. More...

#include <LArWheelCalculator.h>

Collaboration diagram for LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >:

Public Member Functions
	WheelFanCalculator (LArWheelCalculator *lwc)
const LArWheelCalculator *	lwc () const
Geometry methods
virtual double	DistanceToTheNearestFan (CLHEP::Hep3Vector &p, int &out_fan_number) const
virtual int	PhiGapNumberForWheel (int i) const
virtual std::pair< int, int >	GetPhiGapAndSide (const CLHEP::Hep3Vector &p) const

Private Attributes
LArWheelCalculator *	m_lwc

Detailed Description

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

LAr wheel fan calculator, templated for sagging settings.

Definition at line 50 of file LArWheelCalculator.h.

Constructor & Destructor Documentation

WheelFanCalculator()

template<typename SaggingType >

LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::WheelFanCalculator ( LArWheelCalculator *  lwc )

inline

Definition at line 142 of file WheelFanCalculator.h.

        : m_lwc(lwc)
      {
      }

Member Function Documentation

DistanceToTheNearestFan()

template<typename SaggingType >

virtual double LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::DistanceToTheNearestFan ( CLHEP::Hep3Vector &  p, int &  out_fan_number  ) const

inlinevirtual

Definition at line 150 of file WheelFanCalculator.h.

      {
        static const double halfpi=M_PI/2.0;
        int fan_number = int((p.phi() - halfpi - lwc()->m_ZeroFanPhi_ForDetNeaFan) / lwc()->m_FanStepOnPhi);
        const double angle = lwc()->m_FanStepOnPhi * fan_number + lwc()->m_ZeroFanPhi_ForDetNeaFan;
#ifdef HARDDEBUG
        printf("DistanceToTheNearestFan: initial FN %4d\n", fan_number);
#endif
        p.rotateZ(-angle);
        // determine search direction
        typedef DistanceToTheNeutralFibre_OfFan<SaggingType> NFDistance;
 
        const double d0 = NFDistance::calculate(lwc(), fan_number, p);
        //lwc()->set_m_fan_number(fan_number);
        //double d0 = lwc()->DistanceToTheNeutralFibre(p);
 
        const int delta = (d0 < 0.) ? -1 : 1;
        //int delta = 1;          // delta = signof(d0)
        //if(d0 < 0.) delta = -1; // search direction has been determined
 
        const double step_angle = - lwc()->m_FanStepOnPhi * delta;
 
        if (delta > 0) { // forward search
          rotate_to_nearest_fan< SaggingType, FORWARD, NFDistance >( lwc(), fan_number, step_angle, p);
        } else { // backward search
          rotate_to_nearest_fan< SaggingType, BACKWARD, NFDistance >( lwc(), fan_number, step_angle, p);
        }
 
        /*
        double d1 = d0;
        do { // search:
          p.rotateZ(angle);
          fan_number += delta;
 
          d1 = NFDistance::calculate(lwc(), fan_number, p);
          //lwc()->set_m_fan_number(fan_number);
          //d1 = lwc()->DistanceToTheNeutralFibre(p);
 
#ifdef HARDDEBUG
          printf("DistanceToTheNearestFan: step FN %4d %4d\n", fan_number, lwc()->m_fan_number);
#endif
        } while(d0 * d1 > 0.);
        // if signs of d1 and d0 are different, the point is between current pair
        if(delta > 0) fan_number --;
        */
 
        p.rotateZ(-0.5 * step_angle);
#ifdef HARDDEBUG
        printf("DistanceToTheNearestFan: final FN %4d\n", fan_number);
#endif
 
        out_fan_number = lwc()->adjust_fan_number(fan_number);
        return lwc()->DistanceToTheNeutralFibre(p, out_fan_number);
      }

GetPhiGapAndSide()

template<typename SaggingType >

virtual std::pair<int, int> LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::GetPhiGapAndSide ( const CLHEP::Hep3Vector &  p ) const

inlinevirtual

Definition at line 210 of file WheelFanCalculator.h.

      {
    static const double halfpi=M_PI/2.0;
        CLHEP::Hep3Vector p1 = p;
 
        int fan_number = int((p.phi() - halfpi - lwc()->m_ZeroFanPhi) / lwc()->m_FanStepOnPhi);
        const double angle = lwc()->m_FanStepOnPhi * fan_number + lwc()->m_ZeroFanPhi;
        p1.rotateZ(-angle);
 
        typedef DistanceToTheNeutralFibre_OfFan<SaggingType> NFDistance;
 
        const double d0 = NFDistance::calculate(lwc(), fan_number, p1);
        //lwc()->set_m_fan_number(fan_number);
        //double d0 = lwc()->DistanceToTheNeutralFibre(p1);
 
        double d1 = d0;
 
        const int delta = (d0 < 0.) ? -1 : 1;
        //int delta = 1;
        //if(d0 < 0.) delta = -1;
        const double step_angle = - lwc()->m_FanStepOnPhi * delta;
        do {
          p1.rotateZ(step_angle);
          fan_number += delta;
          d1 = NFDistance::calculate(lwc(), fan_number, p1);
          //lwc()->set_m_fan_number(fan_number);
          //d1 = lwc()->DistanceToTheNeutralFibre(p1);
        } while(d0 * d1 > 0.);
 
        if(delta > 0) fan_number --;
        if(!lwc()->m_isElectrode) fan_number ++;
 
        p1.rotateZ(-0.5 * step_angle);
 
        const int a_fan_number = lwc()->adjust_fan_number(fan_number);
        double dd = lwc()->DistanceToTheNeutralFibre(p1, a_fan_number);
        int side = dd < 0.? -1: 1;
#ifdef HARDDEBUG
        printf("GetPhiGapAndSide: MFN %4d\n", a_fan_number);
#endif
        return std::pair<int, int>(a_fan_number, side);
      }

lwc()

template<typename SaggingType >

const LArWheelCalculator* LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::lwc ( ) const

inline

Definition at line 255 of file WheelFanCalculator.h.

{ return m_lwc; };

PhiGapNumberForWheel()

template<typename SaggingType >

virtual int LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::PhiGapNumberForWheel ( int  i ) const

inlinevirtual

Definition at line 205 of file WheelFanCalculator.h.

      {
        return i;
      }

Member Data Documentation

m_lwc

template<typename SaggingType >

LArWheelCalculator* LArWheelCalculator_Impl::WheelFanCalculator< SaggingType >::m_lwc

private

Definition at line 258 of file WheelFanCalculator.h.

---

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

• LArWheelCalculator.h
• WheelFanCalculator.h