/afs/in2p3.fr/throng/virgo/virgoDev/SoftFlorent/Omicron/v2r2/src/Otile.h

Go to the documentation of this file.

//  Author : florent robinet (LAL - Orsay): robinet@lal.in2p3.fr
#ifndef __Otile__
#define __Otile__

#include "Oqplane.h"
#include "GwollumPlot.h"

using namespace std;

class Otile: public GwollumPlot {

 public:

  Otile(const int aTimeRange, 
    const double aQMin, 
    const double aQMax, 
    const double aFrequencyMin, 
    const double aFrequencyMax, 
    const int aSampleFrequency, 
    const double aMaximumMismatch, 
    const string aPlotStyle="GWOLLUM", 
    const int aVerbosity=0);

  virtual ~Otile(void);// destructor
  inline int GetNQ(void){ return nq; };

  inline double GetQ(const int aQindex){
    if(aQindex<0) return -1.0;
    if(aQindex>=nq) return -1.0;
    return qplanes[aQindex]->GetQ();
  };

  bool DrawMapTiling(const int aQindex);

  bool SetPower(Spectrum *aSpec1, Spectrum *aSpec2);

  int ProjectData(fft *aDataFft);

  bool SaveTriggers(TriggerBuffer *aTriggers);

  double SaveMaps(const string aOutdir, const string aName, const string aFormat, vector <int> aWindows, const bool aThumb=false);

  static vector <double> ComputeQs(const double aQMin, const double aQMax, const double aMaximumMismatch);

  inline void SetMapFill(const string aMapFill="snr"){
    if(!aMapFill.compare("amplitude")) mapfill="amplitude";
    else if(!aMapFill.compare("phase")) mapfill="phase";
    else mapfill="snr";
    for(int q=0; q<nq; q++) qplanes[q]->GetZaxis()->SetTitle(StringToUpper(mapfill).c_str());
    return;
  };

  inline void SetRangez(const double aZmin=-1.0, const double aZmax=-1.0){
    vrange[0]=aZmin;
    vrange[1]=aZmax;
  };

  inline void SetSNRThr(const double aSNRThr_map=0.0, const double aSNRThr_trigger=2.0){
    SNRThr_map=aSNRThr_map;
    for(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 int GetTimeRange(void){ return TimeRange; };

  bool SetSegments(Segments *aInSeg, Segments *aOutSeg=NULL);

  inline void SetOverlapDuration(const int aOverlapDuration){
    SeqOverlap=aOverlapDuration+aOverlapDuration%2;
  };

  bool NewChunk(bool &aNewSegFlag);

  inline int GetChunkTimeCenter(void){ return SeqT0; };
  
  inline int GetChunkTimeStart(void){ return SeqT0-TimeRange/2; };
  
  inline int GetChunkTimeEnd(void){ return SeqT0+TimeRange/2; };
  
  inline int GetCurrentOverlapDuration(void){ return SeqOverlapCurrent; };

  inline int GetOverlapDuration(void){ return SeqOverlap; };


 private:

  int fVerbosity;               
  double MaximumMismatch;       
  Oqplane **qplanes;            
  int nq;                       
  int TimeRange;                
  double vrange[2];             
  double SNRThr_map;            
  string mapfill;               
  int **t_snrmax;               
  int **f_snrmax;               

  TH2D* MakeFullMap(const int aTimeRange); 
  void ApplyOffset(TH2D *aMap, const double aOffset);

  // SEQUENCE
  Segments *SeqOutSegments;     
  Segments *SeqInSegments;      
  int SeqOverlap;               
  int SeqOverlapCurrent;        
  int SeqT0;                    
  int SeqSeg;                   

  ClassDef(Otile,0)  
};

#endif

---