AnalyzingAlgorithmResiduals.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
// tracking:
#include <tracking/trackFindingVXD/analyzingTools/algorithms/AnalyzingAlgorithmBase.h>
 
// root:
#include <TMath.h>
#include <Math/VectorUtil.h>
 
namespace Belle2 {

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPX : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPX() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPX) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.X() - tcs.testTC->m_momSeed.X();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPY : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPY() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPY) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.Y() - tcs.testTC->m_momSeed.Y();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPZ : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPZ() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPZ) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.Z() - tcs.testTC->m_momSeed.Z();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPT : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPT() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPT) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.Rho() - tcs.testTC->m_momSeed.Rho();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualP : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualP() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualP) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.R() - tcs.testTC->m_momSeed.R();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPTheta : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPTheta() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPTheta) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.Theta() * TMath::RadToDeg() - tcs.testTC->m_momSeed.Theta() * TMath::RadToDeg();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPPhi : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPPhi() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPPhi) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return tcs.refTC->m_momSeed.Phi() * TMath::RadToDeg() - tcs.testTC->m_momSeed.Phi() * TMath::RadToDeg();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPAngle : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPAngle() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPAngle) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return ROOT::Math::VectorUtil::Angle(tcs.testTC->m_momSeed, tcs.refTC->m_momSeed) * TMath::RadToDeg();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPTAngle : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPTAngle() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPTAngle) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      VectorType refMom = tcs.refTC->m_momSeed;
      refMom.SetZ(0.);
      VectorType testMom = tcs.testTC->m_momSeed;
      testMom.SetZ(0.);
      return ROOT::Math::VectorUtil::Angle(testMom, refMom) * TMath::RadToDeg();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPosition : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPosition() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPosition) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return (tcs.refTC->m_posSeed - tcs.testTC->m_posSeed).R();
    }
  };
 
 

  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmResidualPositionXY : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmResidualPositionXY() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmResidualPositionXY) {}

    DataType calcData(const TCInfoType& aTC) override
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      return (tcs.refTC->m_posSeed - tcs.testTC->m_posSeed).Rho();
    }
  };

}