TrgEclMaster.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 <string>
#include <vector>
 
#include <framework/core/Module.h>
 
#include "trg/ecl/TrgEclCluster.h"
#include "trg/ecl/TrgEclTiming.h"
#include "trg/ecl/TrgEclBhabha.h"
#include "trg/ecl/TrgEclBeamBKG.h"
#include "trg/ecl/TrgEclMapping.h"
//
//
//
namespace Belle2 {
//
//
//
  class TrgEclMaster {
 
  public:
 
    static TrgEclMaster* getTrgEclMaster(void);
 
    TrgEclMaster(void);
 
    virtual ~TrgEclMaster();
 
    TrgEclMaster(TrgEclMaster&) = delete;
 
    TrgEclMaster& operator=(TrgEclMaster&) = delete;
 
  public:
 
    void initialize(int);
    void simulate01(int);
    void simulate02(int);
 
  public:
 
    std::string name(void) const;
 
    std::string version(void) const;
    //  void simulate(int);
    //int getECLtoGDL(void) { return bitECLtoGDL; }
    void setRS(std::vector<int>, std::vector<double>,
               std::vector<double>&, std::vector<std::vector<double>>&);
    //    void getEventTiming(int option);
    void setClusterMethod(int cluster) {_Clustering = cluster;}
    void setClusterLimit(int limit) {_ClusterLimit = limit;}
    void setBhabhaMethod(int bhabha) {_Bhabha = bhabha;}
    void setEventTimingMethod(int EventTiming) {_EventTiming = EventTiming;}
    void setTimeWindow(int timewindow) {TimeWindow = timewindow;}
    void setOverlapWindow(int overlapwindow) {OverlapWindow = overlapwindow;}
    void setNofTopTC(int noftoptc) {_NofTopTC = noftoptc;}
    void makeLowMultiTriggerBit(std::vector<int>, std::vector<double>);
    void makeTriggerBit(int, int, int, int, double, int, int,
                        std::vector<int>, int, int, int, int,
                        int, int, int, int, int, int, int,
                        int, int, int, int);
    double setTotalEnergy(std::vector<double>);
    int getTriggerbit(int i) {return _Triggerbit[i];}
    int getLowmultibit() {return _Lowmultibit;}
    void set2DBhabhaThreshold(const std::vector<double>& i2DBhabhaThresholdFWD,
                              const std::vector<double>& i2DBhabhaThresholdBWD)
    {
      _2DBhabhaThresholdFWD = i2DBhabhaThresholdFWD;
      _2DBhabhaThresholdBWD = i2DBhabhaThresholdBWD;
    }
    void set3DBhabhaSelectionThreshold(const std::vector<double>& i3DBhabhaSelectionThreshold)
    {
      _3DBhabhaSelectionThreshold = i3DBhabhaSelectionThreshold;
    };
    void set3DBhabhaVetoThreshold(const std::vector<double>& i3DBhabhaVetoThreshold)
    {
      _3DBhabhaVetoThreshold = i3DBhabhaVetoThreshold;
    };
 
    void set3DBhabhaSelectionAngle(const std::vector<double>& i3DBhabhaSelectionAngle)
    {
      _3DBhabhaSelectionAngle = i3DBhabhaSelectionAngle;
    };
    void set3DBhabhaVetoAngle(const std::vector<double>& i3DBhabhaVetoAngle)
    {
      _3DBhabhaVetoAngle = i3DBhabhaVetoAngle;
    };
    void setmumuThreshold(int mumuThreshold) {_mumuThreshold = mumuThreshold; }
    void setmumuAngle(const std::vector<double>& imumuAngle)
    {
      _mumuAngle = imumuAngle;
    }
    void set3DBhabhaAddAngleCut(const std::vector<double>&  i3DBhabhaAddAngleCut)
    {
      m_3DBhabhaAddAngleCut = i3DBhabhaAddAngleCut;
    }
    void setTaub2bAngleCut(const std::vector<int>& itaub2bAngleCut)
    {
      m_taub2bAngleCut = itaub2bAngleCut;
    }
    void setTaub2bEtotCut(double itaub2bEtotCut)
    {
      m_taub2bEtotCut = itaub2bEtotCut;
    }
    void setTaub2bClusterECut(double itaub2bClusterECut1,
                              double itaub2bClusterECut2)
    {
      m_taub2bClusterECut1 = itaub2bClusterECut1;
      m_taub2bClusterECut2 = itaub2bClusterECut2;
    }
    // set taub2b2 cut
    void setTaub2b2Cut(const std::vector<int>& iTaub2b2AngleCut,
                       const double iTaub2b2EtotCut,
                       const double iTaub2b2CLEEndcapCut,
                       const double iTaub2b2CLECut)
    {
      m_taub2b2AngleCut     = iTaub2b2AngleCut;
      m_taub2b2EtotCut      = iTaub2b2EtotCut;
      m_taub2b2CLEEndcapCut = iTaub2b2CLEEndcapCut;
      m_taub2b2CLECut       = iTaub2b2CLECut;
    }
    void setn300MeVClusterThreshold(int n300MeVCluster)
    {
      _n300MeVCluster = n300MeVCluster;
    }
    void setECLBurstThreshold(int ECLBurstThreshold)
    {
      _ECLBurstThreshold = (double) ECLBurstThreshold;
    }
    void setTotalEnergyThreshold(const std::vector<double>& iTotalEnergy)
    {
      _TotalEnergy = iTotalEnergy;
    }
    void setLowMultiplicityThreshold(const std::vector<double>& iLowMultiThreshold)
    {
      _LowMultiThreshold = iLowMultiThreshold;
    }
    // set theta ID region (low and high) of 3DBhabhaVeto InTrack for gg selection
    void set3DBhabhaVetoInTrackThetaRegion(const std::vector<int>& i3DBhabhaVetoInTrackThetaRegion)
    {
      m_3DBhabhaVetoInTrackThetaRegion = i3DBhabhaVetoInTrackThetaRegion;
    }
    // set energy threshold(low and high) of event timing quality flag (GeV)
    void setEventTimingQualityThresholds(const std::vector<double>& iEventTimingQualityThresholds)
    {
      m_EventTimingQualityThresholds = iEventTimingQualityThresholds;
    }
 
  private:
 
    std::vector<std::vector<double>>  TCEnergy;
    std::vector<std::vector<double>>  TCTiming;
    std::vector<std::vector<int>>  TCBeamBkgTag;
 
    std::vector<int>  HitTCId;
    std::vector<double>  TCHitEnergy;
    std::vector<double>  TCHitTiming;
    std::vector<int>  TCHitBeamBkgTag;
 
    std::vector< std::vector<double>>  PhiRingSum;
    std::vector<std::vector<std::vector<double>>> ThetaRingSum;
 
    //   std::vector<double> ClusterEnergy;
    //    std::vector<double>  ClusterTiming;
 
    double TimeWindow;
    double OverlapWindow;
 
    int _Clustering;
    int _Bhabha;
    int _EventTiming;
    int _NofTopTC;
    int _ClusterLimit;
    int _Triggerbit[4];
    int _Lowmultibit;
    int _PrescaleFactor;
    int _PrescaleCounter;
 
    std::vector<double> _2DBhabhaThresholdFWD;
    std::vector<double> _2DBhabhaThresholdBWD;
    std::vector<double> _3DBhabhaSelectionThreshold;
    std::vector<double> _3DBhabhaVetoThreshold;
    std::vector<double> _3DBhabhaSelectionAngle;
    std::vector<double> _3DBhabhaVetoAngle;
    double _mumuThreshold;
    std::vector<double> _mumuAngle;
    // Angle selection of additional Bhabha addition in CM frame
    std::vector<double> m_3DBhabhaAddAngleCut;
    // (dphi low, dphi high, theta_sum low, theta_sum high)
    std::vector<int> m_taub2bAngleCut;
    double m_taub2bEtotCut;
    double m_taub2bClusterECut1;
    double m_taub2bClusterECut2;
    // taub2b2 angle selection(degree)
    // (3,2,1,0) = (dphi low, dphi high, theta_sum low, theta_sum high)
    std::vector<int> m_taub2b2AngleCut;
    double m_taub2b2EtotCut;
    // taub2b2 cluster energy cut for endcap cluster (GeV)
    double m_taub2b2CLEEndcapCut;
    double m_taub2b2CLECut;
    int _n300MeVCluster;
    double _ECLBurstThreshold;
    std::vector<double> _TotalEnergy;
    std::vector<double> _LowMultiThreshold;
    // Theta region (low, high) of 3D Bhabha Veto InTrack
    std::vector<int> m_3DBhabhaVetoInTrackThetaRegion;
    // energy threshold(low, high) for quality flag (GeV)
    std::vector<double> m_EventTimingQualityThresholds;
 
    TrgEclMapping* obj_map;
    TrgEclCluster* obj_cluster;
    TrgEclTiming* obj_timing;
    TrgEclBhabha* obj_bhabha;
    TrgEclBeamBKG* obj_beambkg;
    TrgEclDataBase* obj_database;
 
  };
//
//
//
}