BesGlobalTrigSvc.h

Go to the documentation of this file.

#ifndef BesGlobalTrigSvc_h
#define BesGlobalTrigSvc_h 1
 
#include "GaudiKernel/Service.h"
#include "Trigger/IBesGlobalTrigSvc.h"
#include <complex>
#include <fstream>
#include <map>
#include <vector>
 
#include "GaudiKernel/IIncidentListener.h"
#include "RealizationSvc/IRealizationSvc.h"
#include "RealizationSvc/RealizationSvc.h"
#include "Trigger/TrigPara.h"
 
using namespace std;
 
class IDataProviderSvc;
class BesMdcTrig;
class BesEmcTrig;
class BesTofTrig;
class BesMucTrig;
class BesTMTrig;
 
class BesGlobalTrigSvc : public Service,
                         virtual public IIncidentListener,
                         virtual public IBesGlobalTrigSvc {
public:
  BesGlobalTrigSvc( const std::string& name, ISvcLocator* svc );
  virtual ~BesGlobalTrigSvc();
 
public:
  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvInterface );
  /// Initialise the service (Inherited Service overrides)
  virtual StatusCode initialize();
  /// Finalise the service.
  virtual StatusCode finalize();
  // Incident handler
  void handle( const Incident& );
 
  void startMdcTrig();
  void startTofTrig();
  void startEmcTrig();
  void startTMTrig();
 
  StatusCode GlobalTrig();
 
  inline void   setEvtTime( double i ) { m_evttime = i; };
  inline double getEvtTime() { return m_evttime; }
 
  inline void setGoodEvent( bool i ) { m_goodEvent = i; };
  inline bool getGoodEvent() { return m_goodEvent; };
  // set trigger conditions
  StatusCode setTrigCondition();
 
  // values controled in jobOptions
  inline double getL1TC_GATE() { return L1TC_GATE; }
  inline double getL1TC_THRESH() { return L1TC_THRESH; }
  inline int    getL1ETOT_L_Peak() { return L1ETOT_L_Peak; }
  inline int    getL1ETOT_L_Sigma() { return L1ETOT_L_Sigma; }
  inline int    getL1ETOT_M_Peak() { return L1ETOT_M_Peak; }
  inline int    getL1ETOT_M_Sigma() { return L1ETOT_M_Sigma; }
  inline int    getL1ETOT_BR_Peak() { return L1ETOT_BR_Peak; }
  inline int    getL1ETOT_BR_Sigma() { return L1ETOT_BR_Sigma; }
  inline int    getL1ETOT_EC_Peak() { return L1ETOT_EC_Peak; }
  inline int    getL1ETOT_EC_Sigma() { return L1ETOT_EC_Sigma; }
  inline int    getL1EBL_Z_Peak() { return L1EBL_Z_Peak; }
  inline int    getL1EBL_Z_Sigma() { return L1EBL_Z_Sigma; }
  int           getL1ETOT_L();
  int           getL1ETOT_M();
  int           getL1ETOT_BR();
  int           getL1ETOT_EC();
  int           getL1EBL_BR();
  int           getL1EBL_EC();
  int           getL1EDIFF_BR();
  int           getL1EDIFF_EC();
  int           getL1BLK_GATE();
  int           getL1EBL_Z();
 
  inline int    getMAXMDCTRACK() { return MAXMDCTRACK; }
  inline double getEnergy_Ratio() { return Energy_Ratio; }
 
  inline double getBarrelGate() { return emcBarrelGate; }
  inline double getEndGate() { return emcEndGate; }
  inline int    getTofLayerControl() { return m_tofLayer; }
 
  // interface of the trigger channels in each event
  const int  getTrigChan( int i ) { return m_trigChannel[i]; }
  const int* getTrigChan() const { return m_trigChannel; }
 
  inline void setTrigChan( int i, int j ) { m_trigChannel[i] = j; }
 
  // interface to get trigger conditions in each events
  const int  getTrigCond( int i ) { return m_trigCondition[i]; }
  const int* getTrigCond() const { return m_trigCondition; }
 
  inline void setTrigCond( int i, bool j ) {
    trigCond[i] = j;
    if ( j ) m_trigCondition[i] = 1;
    else m_trigCondition[i] = 0;
  }
 
  // set L1 signal
  inline void setIfpass( bool i ) { ifpass = i; }
  // get L1 signal
  inline bool getIfpass() { return ifpass; }
 
  // set run mode
  inline void setRunMode( int mode ) { m_runMode = mode; }
  // get run mode
  inline int getRunMode() { return m_runMode; }
 
  // set MDC information
  // set MDC trigger conditions
  inline void setSTrk_BB( bool i ) { mdc_STrk_BB = i; }
  inline void setNStrkN( bool i ) { mdc_NStrkN = i; }
  inline void setNStrk2( bool i ) { mdc_NStrk2 = i; }
  inline void setNStrk1( bool i ) { mdc_NStrk1 = i; }
  inline void setLTrk_BB( bool i ) { mdc_LTrk_BB = i; }
  inline void setNLtrkN( bool i ) { mdc_NLtrkN = i; }
  inline void setNLtrk2( bool i ) { mdc_NLtrk2 = i; }
  inline void setNLtrk1( bool i ) { mdc_NLtrk1 = i; }
  inline void setNItrk1( bool i ) { mdc_NItrk1 = i; }
  inline void setNItrk2( bool i ) { mdc_NItrk2 = i; }
 
  // set other information of MDC
  inline void setMdcStrkId( std::vector<int> i ) { mdcStrkId = i; }
  inline void setMdcLtrkId( std::vector<int> i ) { mdcLtrkId = i; }
 
  // get MDC information
  // get MDC trigger conditions
  inline bool getSTrk_BB() { return mdc_STrk_BB; }
  inline bool getNStrkN() { return mdc_NStrkN; }
  inline bool getNStrk2() { return mdc_NStrk2; }
  inline bool getNStrk1() { return mdc_NStrk1; }
  inline bool getLTrk_BB() { return mdc_LTrk_BB; }
  inline bool getNLtrkN() { return mdc_NLtrkN; }
  inline bool getNLtrk2() { return mdc_NLtrk2; }
  inline bool getNLtrk1() { return mdc_NLtrk1; }
  inline bool getNItrk1() { return mdc_NItrk1; }
  inline bool getNItrk2() { return mdc_NItrk2; }
  // get other information in MDC
  inline std::vector<int> getMdcStrkId() { return mdcStrkId; }
  inline std::vector<int> getMdcLtrkId() { return mdcLtrkId; }
 
  // set TOF information
  // set TOF trigger conditions
  inline void setETofBB( bool i ) { tof_ETofBB = i; }
  inline void setBTofBB( bool i ) { tof_BTofBB = i; }
  inline void setNETof2( bool i ) { tof_NETof2 = i; }
  inline void setNETof1( bool i ) { tof_NETof1 = i; }
  inline void setNBTof2( bool i ) { tof_NBTof2 = i; }
  inline void setNBTof1( bool i ) { tof_NBTof1 = i; }
  inline void setNTof1( bool i ) { tof_NTof1 = i; }
 
  // set other information of TOF
  inline void setTofHitPos( map<int, vector<int>, greater<int>> i ) { tofHitPos = i; }
  inline void setBTofHitMap( vector<int> i ) { btofHitMap = i; }
  inline void setETofHitMap( vector<int> i ) { etofHitMap = i; }
 
  // get TOF information
  // get TOF trigger conditions
  inline bool getNBTof1() { return tof_NBTof1; }
  inline bool getNBTof2() { return tof_NBTof2; }
  inline bool getNETof1() { return tof_NETof1; }
  inline bool getNETof2() { return tof_NETof2; }
  inline bool getNTof1() { return tof_NTof1; }
  inline bool getBTofBB() { return tof_BTofBB; }
  inline bool getETofBB() { return tof_ETofBB; }
 
  // get other information in TOF
  inline map<int, vector<int>, greater<int>> getTofHitPos() { return tofHitPos; }
  inline vector<int>                         getBTofHitMap() { return btofHitMap; }
  inline vector<int>                         getETofHitMap() { return etofHitMap; }
 
  // set EMC information
  // set trigger conditions
  inline void setNClus1( bool i ) { emc_NClus1 = i; }
  inline void setNClus2( bool i ) { emc_NClus2 = i; }
  inline void setNBClus1( bool i ) { emc_NBClus1 = i; }
  inline void setNEClus1( bool i ) { emc_NEClus1 = i; }
  inline void setBClusBB( bool i ) { emc_BClusBB = i; }
  inline void setEClusBB( bool i ) { emc_EClusBB = i; }
  inline void setClus_Z( bool i ) { emc_Clus_Z = i; }
  inline void setBClus_PHI( bool i ) { emc_BClus_PHI = i; }
  inline void setEClus_PHI( bool i ) { emc_EClus_PHI = i; }
  inline void setBEtot_H( bool i ) { emc_BEtot_H = i; }
  inline void setEEtot_H( bool i ) { emc_EEtot_H = i; }
  inline void setEtot_L( bool i ) { emc_Etot_L = i; }
  inline void setEtot_M( bool i ) { emc_Etot_M = i; }
  inline void setBL_Z( bool i ) { emc_BL_Z = i; }
  inline void setDiff_B( bool i ) { emc_Diff_B = i; }
  inline void setDiff_E( bool i ) { emc_Diff_E = i; }
  inline void setBL_BBLK( bool i ) { emc_BL_BBLK = i; }
  inline void setBL_EBLK( bool i ) { emc_BL_EBLK = i; }
 
  // set other information of EMC
  inline void setEmcNbCluster( int i ) { emcNbCluster = i; }
  inline void setEmcNweCluster( int i ) { emcNweCluster = i; }
  inline void setEmcNeeCluster( int i ) { emcNeeCluster = i; }
  inline void setEmcTotE( double i ) { emcTotE = i; }
  inline void setEmcLTotE( double i ) { emcLTotE = i; }
  inline void setEmcRTotE( double i ) { emcRTotE = i; }
  inline void setEmcBTotE( double i ) { emcBTotE = i; }
  inline void setEmcETotE( double i ) { emcETotE = i; }
  inline void setEmcLBTotE( double i ) { emcLBTotE = i; }
  inline void setEmcRBTotE( double i ) { emcRBTotE = i; }
  inline void setEmcWETotE( double i ) { emcWETotE = i; }
  inline void setEmcEETotE( double i ) { emcEETotE = i; }
  inline void setBTCEnergy( int theta, int phi, double energy ) {
    emcBTCEnergy[theta][phi] = energy;
  }
  inline void setWETCEnergy( int theta, int phi, double energy ) {
    emcWETCEnergy[theta][phi] = energy;
  }
  inline void setEETCEnergy( int theta, int phi, double energy ) {
    emcEETCEnergy[theta][phi] = energy;
  }
  inline void setEmcBlockE( std::vector<double> i ) { emcBlockE = i; }
  inline void setEmcClusId( map<int, vector<complex<int>>, greater<int>> i ) { emcClusId = i; }
  inline void setEmcClusE( std::vector<double> i ) { emcClusE = i; }
 
  // get EMC information
  // get EMC trigger conditions
  inline bool getNClus1() { return emc_NClus1; }
  inline bool getNClus2() { return emc_NClus2; }
  inline bool getNBClus1() { return emc_NBClus1; }
  inline bool getNEClus1() { return emc_NEClus1; }
  inline bool getBClusBB() { return emc_BClusBB; }
  inline bool getEClusBB() { return emc_EClusBB; }
  inline bool getClus_Z() { return emc_Clus_Z; }
  inline bool getBClus_PHI() { return emc_BClus_PHI; }
  inline bool getEClus_PHI() { return emc_EClus_PHI; }
  inline bool getBEtot_H() { return emc_BEtot_H; }
  inline bool getEEtot_H() { return emc_EEtot_H; }
  inline bool getEtot_L() { return emc_Etot_L; }
  inline bool getEtot_M() { return emc_Etot_M; }
  inline bool getBL_Z() { return emc_BL_Z; }
  inline bool getDiff_B() { return emc_Diff_B; }
  inline bool getDiff_E() { return emc_Diff_E; }
  inline bool getBL_BBLK() { return emc_BL_BBLK; }
  inline bool getBL_EBLK() { return emc_BL_EBLK; }
 
  // get other information of EMC
  inline std::vector<double>& getEmcBlockE() { return emcBlockE; };
  inline int                  getEmcNbCluster() { return emcNbCluster; }
  inline int                  getEmcNweCluster() { return emcNweCluster; }
  inline int                  getEmcNeeCluster() { return emcNeeCluster; }
  inline double               getEmcTotE() { return emcTotE; }
  inline double               getEmcLTotE() { return emcLTotE; }
  inline double               getEmcRTotE() { return emcRTotE; }
  inline double               getEmcBTotE() { return emcBTotE; }
  inline double               getEmcETotE() { return emcETotE; }
  inline double               getEmcLBTotE() { return emcLBTotE; }
  inline double               getEmcRBTotE() { return emcRBTotE; }
  inline double               getEmcWETotE() { return emcWETotE; }
  inline double               getEmcEETotE() { return emcEETotE; }
  inline double getBTCEnergy( int theta, int phi ) { return emcBTCEnergy[theta][phi]; }
  inline double getWETCEnergy( int theta, int phi ) { return emcWETCEnergy[theta][phi]; }
  inline double getEETCEnergy( int theta, int phi ) { return emcEETCEnergy[theta][phi]; }
  inline map<int, vector<complex<int>>, greater<int>> getEmcClusId() { return emcClusId; }
  inline std::vector<double>                          getEmcClusE() { return emcClusE; }
 
  // set Muc information
  // set Muc trigger conditions
  inline void setMucBB3478( bool i ) { muc_BB3478 = i; }
  inline void setMucBB37( bool i ) { muc_BB37 = i; }
 
  // set other Muc infor.
  inline void setMucIndex( std::vector<int> i ) { muc_index = i; }
  inline void setMucNtrackBR( int i ) { muc_ntrackBR = i; }
  inline void setMucNtrackEC( int i ) { muc_ntrackEC = i; }
  inline void setMucN3ltrackTotal( int i ) { muc_n3ltracktotal = i; }
 
  // get Muc information
  // get Muc trigger conditions
  inline bool getMucBB3478() { return muc_BB3478; }
  inline bool getMucBB37() { return muc_BB37; }
 
  // get other Muc infor.
  inline std::vector<int> getMuclayerSeg() { return muc_vlayerSeg; }
  inline std::vector<int> getMuchitLayer() { return muc_vhitLayer; }
  inline std::vector<int> getMuchitSeg() { return muc_vhitSeg; }
  inline std::vector<int> getMucIndex() { return muc_index; }
  inline int              getMucNhitEE() { return muc_nhitEE; }
  inline int              getMucNhitBR() { return muc_nhitBR; }
  inline int              getMucNhitWE() { return muc_nhitWE; }
  inline int              getMucNhitTotal() { return muc_nhitTotal; }
  inline int              getMucNlayerBR() { return muc_nlayerBR; }
  inline int              getMucNlayerWE() { return muc_nlayerWE; }
  inline int              getMucNlayerEE() { return muc_nlayerEE; }
  inline int              getMucNtrackBR() { return muc_ntrackBR; }
  inline int              getMucNtrackEC() { return muc_ntrackEC; }
  inline int              getMucN3ltrackTotal() { return muc_n3ltracktotal; }
 
  // set track match trigger conditions
  inline void setTMNATrk1( bool i ) { tm_NATrk1 = i; }
  inline void setTMNATrk2( bool i ) { tm_NATrk2 = i; }
  inline void setTMATrkBB( bool i ) { tm_ATrk_BB = i; }
  inline void setTMNBTrk1( bool i ) { tm_NBTrk1 = i; }
  inline void setTMNBTrk2( bool i ) { tm_NBTrk2 = i; }
  inline void setTMBTrkBB( bool i ) { tm_BTrk_BB = i; }
  inline void setTMNCTrk1( bool i ) { tm_NCTrk1 = i; }
  inline void setTMNCTrk2( bool i ) { tm_NCTrk2 = i; }
  inline void setTMCTrkBB( bool i ) { tm_CTrk_BB = i; }
 
  // get track match trigger conditions
  inline bool getTMNATrk1() { return tm_NATrk1; }
  inline bool getTMNATrk2() { return tm_NATrk2; }
  inline bool getTMATrkBB() { return tm_ATrk_BB; }
  inline bool getTMNBTrk1() { return tm_NBTrk1; }
  inline bool getTMNBTrk2() { return tm_NBTrk2; }
  inline bool getTMBTrkBB() { return tm_BTrk_BB; }
  inline bool getTMNCTrk1() { return tm_NCTrk1; }
  inline bool getTMNCTrk2() { return tm_NCTrk2; }
  inline bool getTMCTrkBB() { return tm_CTrk_BB; }
 
  // get endcap track match mode
  inline int getEndCapMode() { return tm_endcap; }
 
private:
  BesMdcTrig* m_MdcTrig;
  BesTofTrig* m_TofTrig;
  BesEmcTrig* m_EmcTrig;
  BesMucTrig* m_MucTrig;
  BesTMTrig*  m_TMTrig;
 
  std::vector<int> trigOut;
 
  std::vector<std::string> trigChannel;
  std::vector<std::string> trigCondName;
  std::vector<std::string> trigTable;
  std::vector<int>         channelNo;
 
  double m_evttime;
 
  bool m_goodEvent;
 
  // MDC
  // MDC trigger conditions
  bool mdc_STrk_BB, mdc_NStrkN, mdc_NStrk2, mdc_NStrk1;
  bool mdc_LTrk_BB, mdc_NLtrkN, mdc_NLtrk2, mdc_NLtrk1;
  bool mdc_NItrk1, mdc_NItrk2;
 
  // Other variables in MDC
  std::vector<int> mdcStrkId;
  std::vector<int> mdcLtrkId;
 
  // TOF
  // TOF trigger conditions
  bool tof_NBTof1, tof_NBTof2, tof_NETof1, tof_NETof2, tof_NTof1;
  bool tof_BTofBB, tof_ETofBB;
  // Other variables in TOF
  map<int, vector<int>, greater<int>> tofHitPos;
  std::vector<int>                    btofHitMap;
  std::vector<int>                    etofHitMap;
 
  // EMC
  // EMC trigger conditions
  bool emc_NClus1, emc_NClus2, emc_NBClus1, emc_NEClus1, emc_BClusBB, emc_EClusBB, emc_Clus_Z,
      emc_BClus_PHI;
  bool emc_EClus_PHI, emc_BEtot_H, emc_EEtot_H, emc_Etot_L, emc_Etot_M, emc_BL_Z;
  bool emc_Diff_B, emc_Diff_E, emc_BL_BBLK, emc_BL_EBLK;
 
  // Other variables in EMC
  double emcBarrelGate, emcEndGate;
  double emcTotE, emcLTotE, emcRTotE, emcBTotE, emcETotE, emcLBTotE, emcRBTotE, emcWETotE,
      emcEETotE;
  int                                          emcNbCluster, emcNweCluster, emcNeeCluster;
  std::vector<double>                          emcBlockE;
  std::vector<double>                          emcClusE;
  map<int, vector<complex<int>>, greater<int>> emcClusId;
  double emcBTCEnergy[TrigConf::TCTHETANO_B][TrigConf::TCPHINO_B];
  double emcWETCEnergy[TrigConf::TCTHETANO_E][TrigConf::TCPHINO_E];
  double emcEETCEnergy[TrigConf::TCTHETANO_E][TrigConf::TCPHINO_E];
 
  // muc
  // MUC trigger conditions
  bool muc_BB3478, muc_BB37;
 
  // Other variables in MUC
  int              muc_nhitEE, muc_nhitBR, muc_nhitWE, muc_nhitTotal;
  int              muc_nlayerBR, muc_nlayerWE, muc_nlayerEE;
  int              muc_ntrackBR, muc_ntrackEC;
  int              muc_n3ltracktotal;
  std::vector<int> muc_vlayerSeg;
  std::vector<int> muc_vhitLayer;
  std::vector<int> muc_vhitSeg;
  std::vector<int> muc_index;
 
  // Track match
  // TM trigger conditions
  bool tm_NATrk1, tm_NATrk2, tm_ATrk_BB, tm_NBTrk1, tm_NBTrk2, tm_BTrk_BB, tm_NCTrk1,
      tm_NCTrk2, tm_CTrk_BB;
 
  // trigger lines which can trigger events
  std::vector<std::string> vTrigLine;
 
  // trigger condition status in each events
  std::vector<int> vTrigCond;
 
  // trigger condition Id, from 0--47
  bool trigCond[48];
 
  // trigger data which need to be registered to TDS
  int m_trigCondition[48];
  int m_trigChannel[16];
 
  // L1 signal
  bool ifpass;
 
  // run mode
  int         m_runMode;
  int         m_tofLayer;
  std::string trigTableFile;
 
  // property
  double L1TC_GATE;
  double L1TC_THRESH;
  int    L1ETOT_L;
  int    L1ETOT_L_Peak;
  int    L1ETOT_L_Sigma;
  int    L1ETOT_M;
  int    L1ETOT_M_Peak;
  int    L1ETOT_M_Sigma;
  int    L1ETOT_BR;
  int    L1ETOT_BR_Peak;
  int    L1ETOT_BR_Sigma;
  int    L1ETOT_EC;
  int    L1ETOT_EC_Peak;
  int    L1ETOT_EC_Sigma;
  int    L1EBL_BR;
  int    L1EBL_EC;
  int    L1EDIFF_BR;
  int    L1EDIFF_EC;
  int    L1BLK_GATE;
  int    L1EBL_Z;
  int    L1EBL_Z_Peak;
  int    L1EBL_Z_Sigma;
  int    MAXMDCTRACK;
  double Energy_Ratio;
  // endcap track match 0: MDC&TOF; 1: MDC&TOF&EMC
  int tm_endcap;
 
  // Reference to RealizationSvc
  RealizationSvc* m_RealizationSvc;
 
  static const std::string COND_NAME[48]; // The name of each trigger condition
};
#endif