Oomicron.h

Go to the documentation of this file.

 
#ifndef __Oomicron__
#define __Oomicron__
 
#include <IO.h>
#include "Otile.h"
#include "Oinject.h"
#include <Date.h>
#include <InjEct.h>
#include <ffl.h>
 
using namespace std;
 
class Omicron: public GwollumOptions {
 
 public:
  
  Omicron(const string aOptionFile, const bool aOneChannel, const unsigned int aGpsRef=0, const bool aStrict=false);
  
  virtual ~Omicron(void);
  inline void ResetSequence(void){ tile->ResetSequence(); };
 
  bool InitSegments(Segments *aInSeg, Segments *aOutSeg=NULL);
 
  bool MakeDirectories(const double aId = 0.0);
 
  bool NewChunk(void);
 
  bool DefineNewChunk(const unsigned int aTimeStart, const unsigned int aTimeEnd,
                      const bool aResetPsdBuffer=false);
 
  bool NewChannel(void);
 
  inline string GetChannelPrefix(const unsigned int aChannelIndex){
    if(aChannelIndex<GetChannelsN()) return triggers[aChannelIndex]->Streams::GetNamePrefix();
    return "";
  };
 
  inline string GetChannelName(const unsigned int aChannelIndex){
    if(aChannelIndex<GetChannelsN()) return triggers[aChannelIndex]->Streams::GetName();
    return "";
  };
 
  inline string GetChannelName(void){
    if(chanindex>=0) return triggers[chanindex]->Streams::GetName();
    return "";
  };
 
  inline unsigned int GetChannelNativeFrequency(void){
    if(chanindex>=0) return triggers[chanindex]->Streams::GetNativeFrequency();
    return 0;
  };
 
  bool LoadData(double **aDataVector, unsigned int &aSize);
 
  int Condition(const unsigned int aInVectSize, double *aInVect, bool &aIsFlat);
  
  long unsigned int Project(void);
  
  bool WriteOutput(void);
 
  bool ExtractTriggers(double &aTriggerRate);
 
  inline Segments* GetTileSegments(TH1D *aSnrThreshold, const double aPadding){
    return tile->GetTileSegments(aSnrThreshold, aPadding);
  };
 
  inline double GetTileFrequencyMin(void){
    return tile->GetFrequencyMin();
  };
  
  inline double GetTileFrequencyMax(void){
    return tile->GetFrequencyMax();
  };
  
  Long64_t FlushTriggers(void);
 
  string WriteTriggers(const bool aUseLVDir = false);
 
  inline unsigned int GetTriggerSegmentsN(void){
    if(chanindex>=0) return triggers[chanindex]->Segments::GetN();
    return 0;
  }
  
  inline void SetPlotTimeOffset(const double aTimeOffset){ toffset=aTimeOffset; };
  
  inline unsigned int GetChannelsN(void){ return triggers.size(); };
 
  inline unsigned int GetChunkDuration(void){return tile->GetTimeRange();};
 
  inline unsigned int GetOverlapDuration(void){return tile->GetOverlapDuration();};
 
  inline unsigned int GetChunkTimeStart(void){return tile->GetChunkTimeStart();};
 
  inline unsigned int GetChunkTimeEnd(void){return tile->GetChunkTimeEnd();};
 
  inline unsigned int GetQN(void){return tile->GetQN();};
 
  inline double GetQ(const unsigned int aQindex){return tile->GetQ(aQindex);};
 
  inline unsigned int GetBandN(const unsigned int aQindex){return tile->GetBandN(aQindex);};
 
  inline double* GetBands(const unsigned int aQindex){ return tile->GetBands(aQindex); };
 
  inline double GetBandFrequency(const unsigned int aQindex, const unsigned int aBandIndex){
    return tile->GetBandFrequency(aQindex, aBandIndex);
  };
 
  inline unsigned int GetBandTileN(const unsigned int aQindex, const unsigned int aBandIndex){ 
    return tile->GetBandTileN(aQindex, aBandIndex);
  };
 
  inline double GetSnrSqMax(const unsigned int aQindex){ return tile->GetSnrSqMax(aQindex); };
 
  inline double GetTileSnrSq(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){ 
    return tile->GetTileSnrSq(aQindex, aBandIndex, aTimeTileIndex);
  };
 
  inline double GetTileAmplitudeSq(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){
    return tile->GetTileAmplitudeSq(aQindex, aBandIndex, aTimeTileIndex);
  };
 
  inline double GetTileAmplitude(const unsigned int aQindex, const unsigned int aBandIndex, const unsigned int aTimeTileIndex){
    return tile->GetTileAmplitude(aQindex, aBandIndex, aTimeTileIndex);
  };
 
  inline long unsigned int GetTileN(const double aPadding=0.0){return tile->GetTileN(aPadding);};
 
  inline unsigned int GetSampleFrequency(void){return triggers[0]->GetWorkingFrequency();};
 
  inline Long64_t GetTriggerN(void){
    if(chanindex>=0) return triggers[chanindex]->GetTriggerN();
    return 0;
  };
 
  inline double GetSnrThreshold(void){ return tile->GetSnrTriggerThr(); };
  
  inline void ResetPsdBuffer(void) {
    if(chanindex>=0) spectrum1[chanindex]->Reset();
    return;
  };
 
  inline void ResetTriggerBuffer(void) {
    if(chanindex>=0) triggers[chanindex]->TriggerBuffer::Reset();
    return;
  };
  
  void PrintMessage(const string aMessage);
 
  void PrintStatusInfo(void);
  
  vector <string> GetChannels(void);
 
  inline bool GetStatus(void){ return status_OK; };
 
  inline unsigned int GetInjectionChannelN(void){ return GO_InjChan.size(); };
 
  inline bool GetSgInjectionFlag(void){ return GO_InjSg; };
 
  inline unsigned int GetInjGenN(void){
    if(inject!=NULL) return inject[0]->GetN();
    return 0;
  };
 
 
 private:
 
  // STATUS
  bool status_OK;               
  time_t timer;                 
  time_t timer_start;           
  struct tm * ptm;              
  int chanindex;                
 
  // OPTIONS
  unsigned int GO_Verbosity;    
  string GO_OutProducts;        
  string GO_OutFormat;          
  string GO_MainDir;            
  string MainDir;               
  vector<string> GO_InjChan;    
  vector<double> GO_InjFact;    
  bool GO_InjSg;                
  double GO_RateMax;            
  bool GO_thumb;                
 
  // COMPONENTS
  ffl *FFL;                     
  vector<TriggerBuffer*> triggers; 
  Otile *tile;                  
  unsigned int one_channel;     
  Spectrum **spectrum1;         
  Spectrum **spectrum2;         
  Spectrum *spectrumw;          
  ffl *FFL_inject;              
  InjEct **inject;              
  Oinject *oinj;                
  fft *offt;                    
  double *ChunkVect;            
  double *TukeyWindow;          
 
  // OUTPUT
  vector <string> outdir;       
  ofstream osummaryfile;        
  ofstream oinjfile;            
  double toffset;               
 
  // MONITORING
  Segments *inSegments;         
  Segments **outSegments;       
  unsigned int chunk_ctr;       
  unsigned int *chan_data_ctr;  
  unsigned int *chan_cond_ctr;  
  unsigned int *chan_proj_ctr;  
  unsigned int *chan_write_ctr; 
  unsigned int *trig_ctr;       
  double *chan_mapsnrmax;       
  vector <unsigned int> chunkcenter;
  vector <string> chunktfile;   
  
 
  void ReadOptions(const string aOptFile, const bool aStrict=false);
   
  void MakeOptions(void);
 
  void MakeFfl(const unsigned int aGpsRef=0);
 
  void MakeTriggers(void);
 
  void MakeTiling(void);
 
  void MakeSpectrum(const bool aOneChannel);
 
  void MakeInjections(const unsigned int aGpsRef=0);
 
  void Whiten(Spectrum *aSpec, const double aNorm=1.0);
 
  void MakeHtml(void);
 
  void MakeHtmlInit(void);
 
  bool IsFlat(const unsigned int aInVectSize, double *aInVect);
 
  string GetColorCode(const double aSnrRatio);
 
  void SaveSummary(void);
 
  void SaveOptions(void);
 
  void SaveSG(void);
 
  void SaveAPSD(const string aType);
 
  void SaveTS(const bool aWhite=false);
 
  void SaveWPSD(void);
 
  ClassDef(Omicron,0)  
};
 
#endif