InjRea.h

Go to the documentation of this file.

 
#ifndef __InjRea__
#define __InjRea__
 
#include <TChain.h>
#include <TTreeIndex.h>
#include <TH1.h>
#include <TGraph.h>
#include <TMath.h>
#include "InjTyp.h"
#include "Monitor.h"
 
using namespace std;
 
class InjRea{
 
public:
  
  InjRea(const string aPattern, const unsigned int aVerbose=0);
 
  virtual ~InjRea();
  inline Long64_t GetInjectionIndex(void){ return inj_index; };
 
  Long64_t GetInjectionIndexAfter(const double aTime);
 
  inline Long64_t GetFirstInjectionIndexEndAfter(const double aTime){ return GetInjectionIndexAfter(aTime - inj_durmax_p); };
 
  inline Long64_t GetLastInjectionIndexStartBefore(const double aTime){ return GetInjectionIndexAfter(aTime + inj_durmax_m); };
 
  int LoadInjection(const Long64_t aInjIndex);
 
  double GetSineGaussh0plus(void);
 
  double GetSineGaussh0cross(void);
 
  inline unsigned int GetInjectionNameIndex(void){
    unsigned int n = 0;
    for(n=0; n<wave_names.size(); n++)
      if(!(*wave_name).compare(wave_names[n])) break;
    return n;
  };
 
  inline string GetInjectionName(void){ return *wave_name; };
 
  inline unsigned int GetInjectionNameN(void){ return wave_names.size(); };
 
  inline string GetInjectionName(const unsigned int aNameIndex){ return wave_names[aNameIndex]; };
 
  inline injtype GetInjectionType(void){ return (injtype)wave_type; };
 
  inline double GetInjectionTime(void){ return inj_time; };
 
  inline double GetInjectionTimeMin(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_timemin[aNameIndex];
    return inj_timemin[wave_names.size()];
  };
 
  inline double GetInjectionTimeMax(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_timemax[aNameIndex];
    return inj_timemax[wave_names.size()];
  };
 
  inline double GetInjectionRa(void){ return inj_ra; };
 
  inline double GetInjectionDec(void){ return inj_dec; };
 
  inline double GetInjectionEccentricity(void){ return inj_ecc; };
 
  inline double GetInjectionPolarization(void){ return inj_psi; };
 
  inline double GetInjectionAmplitude(void){ return inj_amp; };
 
  inline double GetInjectionAmplitudeMin(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_ampmin[aNameIndex];
    return inj_ampmin[wave_names.size()];
  };
 
  inline double GetInjectionAmplitudeMax(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_ampmax[aNameIndex];
    return inj_ampmax[wave_names.size()];
  };
 
  inline double GetInjectionSigma(void){ return inj_sigma; };
 
  inline double GetInjectionSigmaMin(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_sigmamin[aNameIndex];
    return inj_sigmamin[wave_names.size()];
  };
 
  inline double GetInjectionSigmaMax(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_sigmamax[aNameIndex];
    return inj_sigmamax[wave_names.size()];
  };
  
  inline double GetInjectionFrequency(void){ return inj_f0; };
 
  inline double GetInjectionFrequencyMin(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_f0min[aNameIndex];
    return inj_f0min[wave_names.size()];
  };
 
  inline double GetInjectionFrequencyMax(const unsigned int aNameIndex){
    if(aNameIndex<wave_names.size()) return inj_f0max[aNameIndex];
    return inj_f0max[wave_names.size()];
  };
 
  double GetInjectionTimeStart(void);
 
  double GetInjectionTimeEnd(void);
 
  inline bool GetInjectionTag(void){ return inj_tag[InjTree->GetReadEntry()]; };
 
  inline bool GetInjectionTag(const Long64_t aInjIndex){ return inj_tag[sort_index->GetIndex()[aInjIndex]]; };
 
  inline void SetInjectionTag(const bool aTag){ inj_tag[InjTree->GetReadEntry()]=aTag; };
 
  inline void SetInjectionTag(const Long64_t aInjIndex, const bool aTag){ inj_tag[sort_index->GetIndex()[aInjIndex]]=aTag; };
 
  inline Long64_t GetN(const unsigned int aNameIndex){
    return wave_name_n[aNameIndex];
  };
  
  inline Long64_t GetN(void){ return InjTree->GetEntries(); };
  
  TH1D* GetInjectionParamDist(const string aParamName, const unsigned int aNbins=1, const string aBinType="UNIFORM");
 
  inline string GetInputFilePattern(void){ return pattern; };
 
protected:
  
  Monitor *mon;         
  TGraph *wave_hplus;   
  TGraph *wave_hcross;  
  TChain *InjTree;      
  
private:
  
  string pattern;       
 
  // INJECTION TREE
  Long64_t inj_index;   
  TTreeIndex *sort_index;
  double inj_ra;        
  double inj_dec;       
  double inj_psi;       
  double inj_time;      
  double inj_amp;       
  double inj_f0;        
  double inj_sigma;     
  double inj_ecc;       
 
  // MIN/MAX
  double *inj_timemin;  
  double *inj_timemax;  
  double *inj_sigmamin; 
  double *inj_sigmamax; 
  double *inj_ampmin;   
  double *inj_ampmax;   
  double *inj_f0min;    
  double *inj_f0max;    
 
  bool *inj_tag;        
  double inj_durmax_m;  
  double inj_durmax_p;  
 
  // WAVEFORM TREE
  TChain *WaveTree;     
  UInt_t wave_type;     
  string *wave_name;    
  vector<string> wave_names;
  Long64_t *wave_name_n;
 
  ClassDef(InjRea,0)
};
 
#endif