Triggers.h

Go to the documentation of this file.

 
#ifndef __Triggers__
#define __Triggers__
 
#include <TROOT.h>
#include <TTreeIndex.h>
#include "Segments.h"
 
using namespace std;
 
class Triggers {
 
 public:
 
  Triggers(const unsigned int aVerbose=0);
 
  virtual ~Triggers(void);
  void Reset(void);
  
  bool AddTrigger(const double aTime, const double aFrequency,
          const double aSNR, const double aQ,
          const double aTstart, const double aTend,
          const double aFstart, const double aFend,
          const double aAmplitude, const double aPhase);
 
  bool SortTriggers(void);
 
  inline void SetClusterizeDt(const double aDt){ clusterize_delta_t=aDt; };
 
  inline double GetClusterizeDt(void){ return clusterize_delta_t; };
 
  inline void SetClusterizeSizeMin(const unsigned int aSizeMin){ clusterize_sizemin=aSizeMin; };
 
  inline unsigned int GetClusterizeSizeMin(void){ return clusterize_sizemin; };
 
  inline void SetClusterizeSnrThr(const double aSnrThr){ clusterize_snr_thr=aSnrThr; };
 
  inline double GetClusterizeSnrThr(void){ return clusterize_snr_thr; };
 
  inline void SetClusterTag(const unsigned int aClusterIndex, const int aTag){ Ctag[aClusterIndex]=aTag; };
 
  inline void SetClusterTag(const int aTag){
    for(unsigned int c=0; c<Ctstart.size(); c++) Ctag[c]=aTag;
  };
  
  bool SetTriggerBranchStatus(const string aBname, const bool aStatus=true);
 
  void ResetClusters(void);
  
  bool Clusterize(const int aTag=1);
 
  inline Long64_t GetTriggerN(void){ return Ttree->GetEntries(); };
 
  inline double GetTriggerTime(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Ttime;
    return 0.0;
  };
 
  inline double GetTriggerFrequency(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tfreq;
    return 0.0;
  };
 
  inline double GetTriggerQ(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tq;
    return 0.0;
  };
 
  inline double GetTriggerSnr(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tsnr;
    return 0.0;
  };
 
  inline double GetTriggerTimeStart(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Ttstart;
    return 0.0;
  };
 
  inline double GetTriggerTimeEnd(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Ttend;
    return 0.0;
  };
 
  inline double GetTriggerFrequencyStart(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tfstart;
    return 0.0;
  };
 
  inline double GetTriggerFrequencyEnd(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tfend;
    return 0.0;
  };
 
  inline double GetTriggerAmplitude(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tamp;
    return 0.0;
  };
 
  inline double GetTriggerPhase(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tph;
    return -99.0;
  };
 
  inline double GetTriggerDuration(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Ttend-Ttstart;
    return 0.0;
  };
 
  inline double GetTriggerBandwidth(const Long64_t aTriggerIndex){
    if(Ttree->GetEntry(aTriggerIndex)>0) return Tfend-Tfstart;
    return 0.0;
  };
 
  inline unsigned int GetClusterN(void){ return Ctstart.size(); };
 
  inline double GetClusterTime(const unsigned int aClusterIndex){
    return Ctime[aClusterIndex];
  };
 
  inline double GetClusterFrequency(const unsigned int aClusterIndex){
    return Cfreq[aClusterIndex];
  };
 
  inline double GetClusterQ(const unsigned int aClusterIndex){
    return Cq[aClusterIndex];
  };
 
  inline double GetClusterSnr(const unsigned int aClusterIndex){
    return Csnr[aClusterIndex];
  };
 
  inline double GetClusterTimeStart(const unsigned int aClusterIndex){
    return Ctstart[aClusterIndex];
  };
 
  inline double GetClusterTimeEnd(const unsigned int aClusterIndex){
    return Ctend[aClusterIndex];
  };
 
  inline double GetClusterFrequencyStart(const unsigned int aClusterIndex){
    return Cfstart[aClusterIndex];
  };
 
  inline double GetClusterFrequencyEnd(const unsigned int aClusterIndex){
    return Cfend[aClusterIndex];
  };
 
  inline double GetClusterAmplitude(const unsigned int aClusterIndex){
    return Camp[aClusterIndex];
  };
 
  inline double GetClusterPhase(const unsigned int aClusterIndex){
    return Cph[aClusterIndex];
  };
 
  inline double GetClusterDuration(const unsigned int aClusterIndex){
    return Ctend[aClusterIndex]-Ctstart[aClusterIndex];
  };
 
  inline double GetClusterBandwidth(const unsigned int aClusterIndex){
    return Cfend[aClusterIndex]-Cfstart[aClusterIndex];
  };
 
  inline unsigned int GetClusterSize(const unsigned int aClusterIndex){
    return Csize[aClusterIndex];
  };
 
  inline int GetClusterTag(const unsigned int aClusterIndex){
    return Ctag[aClusterIndex];
  };
 
  inline Long64_t GetClusterFirstTrigger(const unsigned int aClusterIndex){
    return Cfirstentry[aClusterIndex];
  };
 
  inline double GetClusterMeanDuration(void){ return cl_meandur; };
  
  inline double GetClusterMaxDuration(void){ return cl_maxdur; };
  
  inline double GetClusterTotalDuration(void){ return cl_totdur; };
 
  int GetClusterIndex(const double aTime);
 
  bool ReadTriggerFiles(const string aPattern, const string aDirectory="");
 
 protected:
 
  // GENERAL
  int Verbose;         
  int randid;          
  string srandid;      
 
  // TRIGGERS
  TTree *Ttree;        
  TChain *Ttree_read;  
  TTree *Ttree_write;  
  double Ttime;        
  double Tfreq;        
  double Tq;           
  double Tsnr;         
  double Ttstart;      
  double Ttend;        
  double Tfstart;      
  double Tfend;        
  double Tamp;         
  double Tph;          
  int Ttstart_us;      
  Long64_t *Toffsets;  
 
 private:
 
  // CLUSTERS
  vector<double> Ctime;        
  vector<double> Ctstart;      
  vector<double> Ctend;        
  vector<double> Cfreq;        
  vector<double> Cfstart;      
  vector<double> Cfend;        
  vector<double> Csnr;         
  vector<double> Camp;         
  vector<double> Cq;           
  vector<double> Cph;          
  vector<Long64_t> Cfirstentry;
  vector<unsigned int> Csize;  
  vector <int> Ctag;           
  double cl_meandur;           
  double cl_maxdur;            
  double cl_totdur;            
  
  // GENERAL
  bool readmode;           
 
  // CLUSTERIZE
  double clusterize_delta_t;      
  unsigned int clusterize_sizemin;
  double clusterize_snr_thr;      
 
  ClassDef(Triggers,0)  
};
 
#endif