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->momSeed.X() - tcs.testTC->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->momSeed.Y() - tcs.testTC->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->momSeed.Z() - tcs.testTC->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->momSeed.Rho() - tcs.testTC->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->momSeed.R() - tcs.testTC->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->momSeed.Theta() * TMath::RadToDeg() - tcs.testTC->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->momSeed.Phi() * TMath::RadToDeg() - tcs.testTC->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->momSeed, tcs.refTC->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->momSeed;
      refMom.SetZ(0.);
      VectorType testMom = tcs.testTC->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->posSeed - tcs.testTC->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->posSeed - tcs.testTC->posSeed).Rho();
    }
  };
 
}