Otile.h

Go to the documentation of this file.

 
#ifndef __Otile__
#define __Otile__
 
#include "Oqplane.h"
#include "Osequence.h"
#include <GwollumPlot.h>
 
using namespace std;
 
vector <double> ComputeQs(const double aQMin, const double aQMax,
                          const double aMaximumMismatch);
 
 
class Otile: public Osequence, public GwollumPlot {
 
 public:
 
  Otile(const unsigned int aTimeRange,
        const unsigned int aTimeOverlap,
    const double aQMin, 
    const double aQMax, 
    const double aFrequencyMin, 
    const double aFrequencyMax, 
    const unsigned int aSampleFrequency, 
    const double aMaximumMismatch,
        const unsigned int aFullMapNt=1,
    const string aPlotStyle="GWOLLUM", 
    const unsigned int aVerbosity=0);
 
  virtual ~Otile(void);
  inline unsigned int GetQN(void){ return nq; };
 
  inline double GetQ(const unsigned int aQindex){
    if(aQindex<nq) return qplanes[aQindex]->GetQ();
    return 0.0;
  };
 
  inline unsigned int GetBandN(const unsigned int aQindex){
    if(aQindex<nq) return qplanes[aQindex]->GetBandN();
    return qplanes[nq-1]->GetBandN();
  };
 
  inline double GetBandFrequency(const unsigned int aQindex, const unsigned int aBandIndex){
    if(aQindex<nq) return qplanes[aQindex]->GetBandFrequency(aBandIndex);
    return qplanes[nq-1]->GetBandFrequency(aBandIndex);
  };
 
  inline unsigned int GetBandTileN(const unsigned int aQindex, const unsigned int aBandIndex){ 
    if(aQindex<nq) return qplanes[aQindex]->GetBandTileN(aBandIndex);
    if(FullMapNt>0) return FullMapNt;
    return qplanes[0]->GetBandTileN(qplanes[0]->GetBandN()-1);
  };
 
  inline double GetTileSnrSq(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){ 
    return qplanes[aQindex]->GetTileSnrSq(aTimeTileIndex, aBandIndex);
  };
 
  inline double GetTileAmplitude(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){
    return qplanes[aQindex]->GetTileAmplitude(aTimeTileIndex, aBandIndex);
  };
 
  inline double GetTileAmplitudeSq(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){
    return qplanes[aQindex]->GetTileAmplitudeSq(aTimeTileIndex, aBandIndex);
  };
 
  inline double GetSnrSqMax(const unsigned int aQindex){ return qplanes[aQindex]->GetSnrSqMax(); };
 
  long unsigned int GetTileN(const double aPadding=0.0);
 
  double* GetBands(const unsigned int aQindex);
 
  void SetPlotTimeWindows(vector <unsigned int> aWindows);
  
  inline vector <unsigned int> GetPlotTimeWindows(void){ return pwin; };
 
  void DrawMapTiling(const unsigned int aQindex);
 
  inline void SetPower(Spectrum *aSpec1, Spectrum *aSpec2){
    for(unsigned int q=0; q<nq; q++) qplanes[q]->SetPower(aSpec1, aSpec2);
  };
  
  long unsigned int ProjectData(fft *aDataFft);
 
  Segments* GetTileSegments(TH1D *aSnrThreshold, const double aPadding);
 
  bool SaveTriggers(TriggerBuffer *aTriggers);
 
  double SaveMaps(const string aOutdir, const string aName, const string aFormat,
                  const double aTimeOffset=0.0, const bool aThumb=false);
 
  inline void SetMapFill(const string aMapContentType="snr"){
    if(!aMapContentType.compare("amplitude")) mapfill="amplitude";
    else if(!aMapContentType.compare("phase")) mapfill="phase";
    else mapfill="snr";
    return;
  };
 
  inline void SetRangez(const double aZmin=-1.0, const double aZmax=-1.0){
    vrange[0] = aZmin;
    vrange[1] = aZmax;
  };
 
  inline double GetRangezMin(void){ return vrange[0]; };
 
  inline void SetSnrThr(const double aSnrThr_map=0.0, const double aSnrThr_trigger=2.0){
    SnrThr_map=aSnrThr_map;
    for(unsigned int q=0; q<nq; q++) qplanes[q]->SetSnrThr(aSnrThr_trigger);
  };
  
  inline string GetMapFill(void){ return mapfill; };
 
  inline double GetSnrMapThr(void){ return SnrThr_map; };
 
  inline double GetSnrTriggerThr(void){ return qplanes[0]->GetSnrThr(); };
 
  inline double GetFrequencyMin(void){ return qplanes[0]->GetFrequencyMin(); };
 
  inline double GetFrequencyMax(void){ return qplanes[nq-1]->GetFrequencyMax(); };
 
  inline double GetMismatchMax(void){ return MaximumMismatch; };
 
  inline unsigned int GetTimeRange(void){ return qplanes[0]->GetTimeRange(); };
 
  inline void SetChirp(const double aMchirp=-1.0, const double aMergerTime=-1.0){
    chirpt = aMergerTime;
    chirpm = aMchirp;
    chirp->SetParameters(-8.0*96.0/3.0/5.0*TMath::Power(TMath::Pi(),8.0/3.0)*TMath::Power(TMath::G()*chirpm*1.989e30/TMath::C()/TMath::C()/TMath::C(), 5.0/3.0),
    aMergerTime);
  }
 
  inline double GetChirpMass(void){ return chirpm; };
 
  inline void FillMaps(void){
    for(unsigned int q=0; q<nq; q++)
      qplanes[q]->FillMap(mapfill, -(double)GetTimeRange()/2.0, (double)GetTimeRange()/2.0);
  };
 
  void FillFullMap(const unsigned int aWindowIndex, const double aTimeOffset = 0.0);
 
  inline TH2D* GetFullMap(const unsigned int aWindowIndex){
    return (TH2D*)fullmap[aWindowIndex]->Clone();
  };
 
 private:
 
  unsigned int fVerbosity;      
  double MaximumMismatch;       
  Oqplane **qplanes;            
  unsigned int nq;              
  double vrange[2];             
  double SnrThr_map;            
  string mapfill;               
  unsigned int **t_snrmax;      
  unsigned int **f_snrmax;      
  TF1 *chirp;                   
  double chirpm;                
  double chirpt;                
  vector <unsigned int> pwin;   
 
  // FULL MAP
  TH2D **fullmap;               
  unsigned int FullMapNt;       
 
  ClassDef(Otile,0)
};
 
#endif