Segments.h

Go to the documentation of this file.

 
#ifndef __Segments__
#define __Segments__
 
#include "ReadAscii.h"
#include <TFile.h>
#include <TChain.h>
#include <TH1.h>
 
using namespace std;
 
class Segments {
  
 public:
  
  Segments(void);
  
  Segments(const string aSegmentFile,
           const int aDefaultTag=1);
 
  Segments(TTree *aSegmentTree);
 
  Segments(const string aFilePattern, const string aDirectory, const string aTreeName);
 
  Segments(const vector<double> aGpsStarts, const vector<double> aGpsEnds);
 
  Segments(const double aGpsStart, const double aGpsEnd, const int aTag=1);
 
  virtual ~Segments(void);  
  void Reset(void);
 
  inline bool GetStatus(void) const { return status; };
 
  int GetSegmentStartBefore(const double aGps);
 
  inline unsigned int GetN(void){ return seg_start.size(); };
 
  unsigned int GetNWithTag(const int aTag);
 
  inline vector<double> GetStarts(void){ return seg_start; };
 
  inline vector<double> GetEnds(void){ return seg_end; };
 
  inline vector<int> GetTags(void){ return seg_tag; };
 
  inline double GetStart(const unsigned int aSegmentIndex=0){ return seg_start[aSegmentIndex]; };
 
  inline double GetEnd(const unsigned int aSegmentIndex=0){ return seg_end[aSegmentIndex]; };
 
  inline double GetFirst(){ return GetStart(0); };
 
  inline double GetLast(){ return GetEnd(GetN()-1); };
 
  inline double GetDuration(const unsigned int aSegmentIndex=0){ return seg_end[aSegmentIndex]-seg_start[aSegmentIndex]; };
 
  inline int GetTag(const unsigned int aSegmentIndex=0){ return seg_tag[aSegmentIndex]; };
 
  inline double GetLiveTime(void){ return seg_livetime; };
 
  double GetLiveTime(const double aGpsStart, const double aGpsEnd);
 
  inline double GetLiveTime(const unsigned int aSegmentIndex){ return GetDuration(aSegmentIndex); };
 
  double GetLiveTimeWithTag(const int aTag);
 
  TH1I* GetHistogram(const double aGpsStart, const double aGpsEnd, const double aOffset=0.0);
 
  inline TH1I* GetHisto(const double aOffset=0.0){
    return GetHistogram(seg_start[0],seg_end[seg_start.size()-1],aOffset);
  };
 
  TTree* GetTree(const double aGpsStart, const double aGpsEnd);
 
  TTree* GetTree(void){
    if(GetN()) return GetTree(seg_start[0], seg_end[seg_start.size()-1]);
    return GetTree(0.0, 0.0);
  };
 
  bool IsInsideSegment(unsigned int &aSegmentIndex, const double aGps);
      
  bool IsInsideSegment(const double aGps);
 
  inline void SetTag(const unsigned int aSegmentIndex, const int aTag){
    seg_tag[aSegmentIndex] = aTag;
  };
 
  void SetTags(const int aTag);
 
  bool Append(const double aGpsStart, const double aGpsEnd, const int aTag=1);
 
  bool Append(vector <double> aGpsStarts, vector <double> aGpsEnds, vector <double> aTags);
 
  bool Append(Segments *aSeg);
 
  bool Append(TTree *aSegmentTree);
  
  bool AddSegment(const double aGpsStart, const double aGpsEnd, const int aTag=1);
  
  bool AddSegments(Segments *aSeg);
  
  bool ApplyPadding(const double aPadStart, const double aPadEnd);
 
  bool TruncateAfter(const double aGps);
 
  bool TruncateBefore(const double aGps);
 
  bool MakeSecond(void);
 
  bool Reverse(void);
  
  bool Intersect(Segments *aSeg);
 
  bool Intersect(const double aGpsStart, const double aGpsEnd, const int aTag=1);
 
  void Dump(unsigned int aNcols=2, const string aTxtFileName="");
 
 private:
  
  bool status;                    
  vector<double> seg_start;       
  vector<double> seg_end;         
  vector<int> seg_tag;            
  double seg_livetime;            
  vector <unsigned int> time_mark;
  vector <unsigned int> n_mark;   
 
  inline int GetTagProduct(const int aTag1, const int aTag2){
    if(aTag1<0||aTag2<0) return TMath::Min(aTag1,aTag2);
    return TMath::Max(aTag1,aTag2);
  };
 
  bool CheckConsistency(const unsigned int aStartIndex);
 
  void MergeOverlaps(const unsigned int aStartIndex);
 
  void SetMarks(void);
  
  int GetMark(const unsigned int aGps);
  
  void ComputeLiveTime(void);
 
 
  ClassDef(Segments,0)
};
 
#endif