TwoHitFilters.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler                                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <TVector3.h>
#include <math.h>
 
 
 
namespace Belle2 {
  class TwoHitFilters {
  public:
 
    TwoHitFilters():
      m_x2(0.),
      m_y2(0.),
      m_z2(0.),
      m_dz(0.)
    {
      m_hitA.SetXYZ(0., 0., 0.);
      m_hitB.SetXYZ(0., 0., 0.);
    }
 
    TwoHitFilters(TVector3& outerHit, TVector3& innerHit):
      m_hitA(outerHit),
      m_hitB(innerHit) { initializeMe(outerHit, innerHit); }
 
 
    ~TwoHitFilters() {}
 
    void resetValues(TVector3& outerHit, TVector3& innerHit)
    {
      m_hitA = outerHit;
      m_hitB = innerHit;
 
      initializeMe(outerHit, innerHit);
    }
 
    double calcDist3D() const { return (m_x2 + m_y2 + m_z2); } // return unit: cm^2
 
    double fullDist3D() const { return sqrt(calcDist3D()); } // return unit: cm
 
    double calcDistXY() const { return (m_x2 + m_y2); } // return unit: cm^2
 
    double fullDistXY() const { return sqrt(calcDistXY()); } // return unit: cm
 
    double calcDistZ() const { return m_dz; } // return unit: cm
 
    double calcSlopeRZ() const
    {
      //double slope = atan (calcDistXY() / m_dz) ;
      double slope = atan(fullDistXY() / m_dz) ;    //since calcDistXY() returns cm ^2
      return filterNan(slope);
    } // return unit: radians
 
    double fullSlopeRZ() const { return calcSlopeRZ(); }
 
    double calcNormedDist3D() const
    {
      double normedVal = calcDistXY() / calcDist3D();
      return filterNan(normedVal);
    } // return unit: none
 
    double filterNan(double value) const;
 
  protected:
 
    void initializeMe(TVector3& outerHit, TVector3& innerHit)
    {
      m_x2 = outerHit[0] - innerHit[0]; // not x2 yet, reusing member
      m_y2 = outerHit[1] - innerHit[1];
      m_dz = outerHit[2] - innerHit[2];
 
      m_x2 *= m_x2; // now it's x2...
      m_y2 *= m_y2;
      m_z2 = m_dz * m_dz;
    }
 
    TVector3 m_hitA; 
    TVector3 m_hitB; 
    double m_x2; 
    double m_y2; 
    double m_z2; 
    double m_dz; 
  }; //end class TwoHitFilters
} //end namespace Belle2