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(void);
    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) {m_Clustering = cluster;}
    void setClusterLimit(int limit) {m_ClusterLimit = limit;}
    void setBhabhaMethod(int bhabha) {m_Bhabha = bhabha;}
    void setEventTimingMethod(int EventTiming) {m_EventTiming = EventTiming;}
    void setTimeWindow(int timewindow) {m_TimeWindow = timewindow;}
    void setOverlapWindow(int overlapwindow) {m_OverlapWindow = overlapwindow;}
    void setNofTopTC(int noftoptc) {m_NofTopTC = noftoptc;}
    void makeLowMultiTriggerBit(std::vector<int>, std::vector<double>, int);

    /*
    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);
    */
    void makeTriggerBit(int, int, int, int, double,
                        int, int, int, int, int,
                        std::vector<int>, int, int, int, int,
                        int, int, int, int, int, int, int,
                        int, int, int, int, int);//one int parameter was added for taub2b3

    double setTotalEnergy(std::vector<double>);
    int getTriggerbit(int i) {return m_Triggerbit[i];}
    int getLowmultibit() {return m_Lowmultibit;}

    void setADCtoEnergy(const double ADCtoEnergy)
    {
      m_ADCtoEnergy = ADCtoEnergy;
    }

    void setTotalEnergyThreshold(const std::vector<double>& iTotalEnergy)
    {
      m_TotalEnergy = iTotalEnergy;
    }

    void set2DBhabhaThreshold(const std::vector<double>& i2DBhabhaThresholdFWD,
                              const std::vector<double>& i2DBhabhaThresholdBWD)
    {
      m_2DBhabhaThresholdFWD = i2DBhabhaThresholdFWD;
      m_2DBhabhaThresholdBWD = i2DBhabhaThresholdBWD;
    }

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

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

    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 setTaub2bAngleCut(const std::vector<int>& itaub2bAngleCut)
    {
      m_taub2bAngleCut = itaub2bAngleCut;
    }

    void setTaub2bEtotCut(double itaub2bEtotCut)
    {
      m_taub2bEtotCut = itaub2bEtotCut;
    }

    void setTaub2bCLELabCut(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 setECLBurstThreshold(int ECLBurstThreshold)
    {
      m_ECLBurstThreshold = (double) ECLBurstThreshold;
    }

    void setlmlCLELabCut(const std::vector<double>& ilmlCLELabCut)
    {
      m_lmlCLELabCut = ilmlCLELabCut;
    }

    void setlmlCLECMSCut(const std::vector<double>& ilmlCLECMSCut)
    {
      m_lmlCLECMSCut = ilmlCLECMSCut;
    }

    void setlml00NCLforMinE(const int ilml00NCLforMinE)
    {
      m_lml00NCLforMinE = ilml00NCLforMinE;
    }

    void setlml12NCLforMinE(const int ilml12NCLforMinE)
    {
      m_lml12NCLforMinE = ilml12NCLforMinE;
    }

    void setlml13ThetaIdSelection(const int ilml13ThetaIdSelection)
    {
      m_lml13ThetaIdSelection = ilml13ThetaIdSelection;
    }

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

    void setEventTimingQualityThreshold(const std::vector<double>& iEventTimingQualityThreshold)
    {
      m_EventTimingQualityThreshold = iEventTimingQualityThreshold;
    }

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

    void setBhabhaParameter(void);
 
  private:

    std::vector<std::vector<double>>  m_TCEnergy;
    std::vector<std::vector<double>>  m_TCTiming;
    std::vector<std::vector<int>>  m_TCBeamBkgTag;

    std::vector<int>  m_HitTCId;
    std::vector<double>  m_TCHitEnergy;
    std::vector<double>  m_TCHitTiming;
    std::vector<int>  m_TCHitBeamBkgTag;

    std::vector< std::vector<double>>  m_PhiRingSum;
    std::vector<std::vector<std::vector<double>>> m_ThetaRingSum;

    //   std::vector<double> ClusterEnergy;
    //    std::vector<double>  ClusterTiming;

    double m_TimeWindow;
    double m_OverlapWindow;

    int m_Clustering;
    int m_Bhabha;
    int m_EventTiming;
    int m_NofTopTC;
    int m_ClusterLimit;
    int m_Triggerbit[4];
    int m_Lowmultibit;
    int m_PrescaleFactor;
    int m_PrescaleCounter;

    double m_ADCtoEnergy;
    std::vector<double> m_TotalEnergy;
    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_taub2bEtotCut;
    double m_taub2bCLELabCut;
    std::vector<int> m_taub2b2AngleCut;
    double m_taub2b2EtotCut;
    std::vector<double> m_taub2b2CLELabCut;
    std::vector<int> m_taub2b3AngleCut;
    double m_taub2b3EtotCut;
    double m_taub2b3CLEb2bLabCut;
    std::vector<double> m_taub2b3CLELabCut;
    double m_ECLBurstThreshold;
    std::vector<double> m_lmlCLELabCut;
    std::vector<double> m_lmlCLECMSCut;
    int m_lml00NCLforMinE;
    int m_lml12NCLforMinE;
    int m_lml13ThetaIdSelection;
    std::vector<int> m_3DBhabhaVetoInTrackThetaRegion;
    std::vector<double> m_EventTimingQualityThreshold;
    double m_hie4LowCLELabCut;

    TrgEclMapping* m_obj_map;
    TrgEclCluster* m_obj_cluster;
    TrgEclTiming* m_obj_timing;
    TrgEclBhabha* m_obj_bhabha;
    TrgEclBeamBKG* m_obj_beambkg;
    TrgEclDataBase* m_obj_database;
 
  };
//
//
//
} // namespace Belle2