TrgEclBhabha.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
 
#include <vector>
 
#include "trg/ecl/TrgEclMapping.h"
#include "trg/ecl/TrgEclDataBase.h"
 
#include <Math/Vector3D.h>
 
//
//
//
namespace Belle2 {
//
//
//
  //
  //
  class TrgEclBhabha {
 
  public:
    TrgEclBhabha();    

    virtual ~TrgEclBhabha();

    TrgEclBhabha(TrgEclBhabha&) = delete;

    TrgEclBhabha& operator=(TrgEclBhabha&) = delete;
 
  public:
    bool getBhabha00(std::vector<double>);
    bool getBhabha01();
    bool getBhabha02();
    bool getmumu();
    bool getTaub2b(double);
    bool getTaub2b2(double);
    bool getTaub2b3(double);
    int getBhabhaAddition(void);
    std::vector<double> getBhabhaComb() {return m_BhabhaComb ;}
    void save(int);
    void set2DBhabhaThreshold(const std::vector<double>& i2DBhabhaThresholdFWD,
                              const std::vector<double>& i2DBhabhaThresholdBWD)
    {
      m_2DBhabhaThresholdFWD = i2DBhabhaThresholdFWD;
      m_2DBhabhaThresholdBWD = i2DBhabhaThresholdBWD;
    }

    void set3DBhabhaVetoAngle(const std::vector<int>& i3DBhabhaVetoAngle)
    {
      m_3DBhabhaVetoAngle = i3DBhabhaVetoAngle;
    };

    void set3DBhabhaVetoThreshold(const std::vector<double>& i3DBhabhaVetoThreshold)
    {
      m_3DBhabhaVetoThreshold = i3DBhabhaVetoThreshold;
    };

    void set3DBhabhaSelectionThreshold(const std::vector<double>& i3DBhabhaSelectionThreshold)
    {
      m_3DBhabhaSelectionThreshold = i3DBhabhaSelectionThreshold;
    };

    void set3DBhabhaSelectionAngle(const std::vector<int>& i3DBhabhaSelectionAngle)
    {
      m_3DBhabhaSelectionAngle = i3DBhabhaSelectionAngle;
    };

    void set3DBhabhaSelectionPreScale(const std::vector<int>& i3DBhabhaSelectionPreScale)
    {
      m_3DBhabhaSelectionPreScale = i3DBhabhaSelectionPreScale;
    };

    void setmumuThreshold(double mumuThreshold) { m_mumuThreshold = mumuThreshold; }
    void setmumuAngle(const std::vector<int>& imumuAngle) { m_mumuAngle = imumuAngle; }
    void sethie12BhabhaVetoAngle(const std::vector<int>& ihie12BhabhaVetoAngle)
    {
      m_hie12BhabhaVetoAngle = ihie12BhabhaVetoAngle;
    }

    void set3DBhabhaVetoInTrackThetaRegion(const std::vector<int>& i3DBhabhaVetoInTrackThetaRegion)
    {
      m_3DBhabhaVetoInTrackThetaRegion = i3DBhabhaVetoInTrackThetaRegion;
    }

    void setTaub2bAngleCut(const std::vector<int>& iTaub2bAngleCut)
    {
      m_taub2bAngleCut = iTaub2bAngleCut;
    }

    void setTaub2bEtotCut(const double iTaub2bEtotCut)
    {
      m_taub2bEtotCut = iTaub2bEtotCut;
    }

    void setTaub2bCLELabCut(const double iTaub2bCLELabCut)
    {
      m_taub2bCLELabCut = iTaub2bCLELabCut;
    }

    void setTaub2b2Cut(const std::vector<int>& iTaub2b2AngleCut,
                       const double iTaub2b2EtotCut,
                       const std::vector<double>& iTaub2b2CLELabCut)
    {
      m_taub2b2AngleCut  = iTaub2b2AngleCut;
      m_taub2b2EtotCut   = iTaub2b2EtotCut;
      m_taub2b2CLELabCut = iTaub2b2CLELabCut;
    }

    void setTaub2b3Cut(const std::vector<int>& iTaub2b3AngleCut,
                       const double iTaub2b3EtotCut,
                       const double iTaub2b3CLEb2bLabCut,
                       const std::vector<double>& iTaub2b3CLELabCut)
    {
      m_taub2b3AngleCut     = iTaub2b3AngleCut;
      m_taub2b3EtotCut      = iTaub2b3EtotCut;
      m_taub2b3CLEb2bLabCut = iTaub2b3CLEb2bLabCut;
      m_taub2b3CLELabCut    = iTaub2b3CLELabCut;
    }

    void sethie4LowCLELabCut(const double hie4LowCLELabCut)
    {
      m_hie4LowCLELabCut = hie4LowCLELabCut;
    }

    int get3DBhabhaVetoInTrackFlag(void)
    {
      return m_3DBhabhaVetoInTrackFlag;
    }

    int get3DBhabhaVetoClusterTCId(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaVetoClusterTCIds.size() != 2) {
        return -10;
      }
      return m_3DBhabhaVetoClusterTCIds[cl_idx];
    }

    int get3DBhabhaVetoClusterThetaId(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaVetoClusterThetaIds.size() != 2) {
        return -10;
      }
      return m_3DBhabhaVetoClusterThetaIds[cl_idx];
    }

    double get3DBhabhaVetoClusterEnergy(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaVetoClusterEnergies.size() != 2) {
        return -10;
      }
      return m_3DBhabhaVetoClusterEnergies[cl_idx];
    }

    double get3DBhabhaVetoClusterTiming(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaVetoClusterTimings.size() != 2) {
        return -1000;
      }
      return m_3DBhabhaVetoClusterTimings[cl_idx];
    }

    int get3DBhabhaSelectionThetaFlag(void)
    {
      return m_3DBhabhaSelectionThetaFlag;
    }

    int get3DBhabhaSelectionClusterTCId(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaSelectionClusterTCIds.size() != 2) {
        return -10;
      }
      return m_3DBhabhaSelectionClusterTCIds[cl_idx];
    }

    int get3DBhabhaSelectionClusterThetaId(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaSelectionClusterThetaIds.size() != 2) {
        return -10;
      }
      return m_3DBhabhaSelectionClusterThetaIds[cl_idx];
    }

    double get3DBhabhaSelectionClusterEnergy(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaSelectionClusterEnergies.size() != 2) {
        return -10;
      }
      return m_3DBhabhaSelectionClusterEnergies[cl_idx];
    }

    double get3DBhabhaSelectionClusterTiming(int cl_idx)
    {
      if (cl_idx < 0 || cl_idx > 1 || m_3DBhabhaSelectionClusterTimings.size() != 2) {
        return -1000;
      }
      return m_3DBhabhaSelectionClusterTimings[cl_idx];
    }

    int getTaub2bAngleFlag(void) { return m_taub2bAngleFlag; }
    int getTaub2bEtotFlag(void) { return m_taub2bEtotFlag; }
    int getTaub2bClusterEFlag(void) { return m_taub2bClusterEFlag; }
 
  private:
    TrgEclMapping* m_TCMap = nullptr;
    TrgEclDataBase* m_database = nullptr;

    void get2CLETP(int, int, int&, int&, int&, int&);

    std::vector<double> m_BhabhaComb;
    std::vector<double> m_MaxTCId;
    std::vector<double> m_MaxTCThetaId;
    std::vector<double> m_ClusterEnergyLab;
    std::vector<double> m_ClusterTiming;
    std::vector<double> m_2DBhabhaThresholdFWD;
    std::vector<double> m_2DBhabhaThresholdBWD;
    std::vector<double> m_3DBhabhaVetoThreshold;
    std::vector<int> m_3DBhabhaVetoAngle;
    std::vector<double> m_3DBhabhaSelectionThreshold;
    std::vector<int> m_3DBhabhaSelectionAngle;
    std::vector<int> m_3DBhabhaSelectionPreScale;
    double m_mumuThreshold;
    std::vector<int> m_mumuAngle;
    std::vector<int> m_hie12BhabhaVetoAngle;
 

    std::vector<int> m_taub2bAngleCut;
    double m_taub2bCLELabCut;
    double m_taub2bEtotCut;
 

    int m_taub2bAngleFlag;
    int m_taub2bEtotFlag;
    int m_taub2bClusterEFlag;
    double m_taub2b2EtotCut;
    std::vector<int> m_taub2b2AngleCut;
    std::vector<double> m_taub2b2CLELabCut;
    std::vector<int> m_taub2b3AngleCut;
    double m_taub2b3EtotCut;
    double m_taub2b3CLEb2bLabCut;
    std::vector<double> m_taub2b3CLELabCut;
    double m_hie4LowCLELabCut;
    int                 m_3DBhabhaVetoInTrackFlag;
    std::vector<int>    m_3DBhabhaVetoClusterTCIds;
    std::vector<int>    m_3DBhabhaVetoClusterThetaIds;
    std::vector<double> m_3DBhabhaVetoClusterEnergies;
    std::vector<double> m_3DBhabhaVetoClusterTimings;
    std::vector<int>    m_3DBhabhaVetoInTrackThetaRegion;
    int m_3DBhabhaSelectionThetaFlag = std::numeric_limits<int>::quiet_NaN();
    std::vector<int>    m_3DBhabhaSelectionClusterTCIds;
    std::vector<int>    m_3DBhabhaSelectionClusterThetaIds;
    std::vector<double> m_3DBhabhaSelectionClusterEnergies;
    std::vector<double> m_3DBhabhaSelectionClusterTimings;
  };
//
//
//
} // namespace Belle2