Analyzer.h

#ifndef UCORRELATOR_ANALYZER_H
#define UCORRELATOR_ANALYZER_H

#include "Correlator.h" 
#include "WaveformCombiner.h"
#include "UCorrelatorGUI.h" 
#include <vector>
#include "TH2D.h"
#include "simpleStructs.h"
#include "AnitaEventSummary.h" 
#include "ResponseManager.h" 
#include "UsefulAnitaEvent.h" 

class FilteredAnitaEvent; 
class UsefulAdu5Pat; 
class AnalysisWaveform; 
class TPad; 

namespace FFTtools
{
  class DigitalFilter; 
}

namespace UCorrelator
{

  class AnalysisConfig; 

  class Analyzer
  {

    public:
      Analyzer(const AnalysisConfig * cfg = 0, bool interactive = false); 

      virtual ~Analyzer();



      void analyze(const FilteredAnitaEvent * event, AnitaEventSummary *summary, const TruthAnitaEvent * truth = 0); 

      Correlator * getCorrelator() { return &corr; } 

      WaveformCombiner * getWaveformCombiner() { return &wfcomb; } 

      WaveformCombiner * getXPolWaveformCombiner() { return &wfcomb_xpol; } 


      const gui::Map * getCorrelationMap(AnitaPol::AnitaPol_t pol) const  { return correlation_maps[pol] ; } 

      const gui::Map * getZoomedCorrelationMap(AnitaPol::AnitaPol_t pol, int i) const { return zoomed_correlation_maps[pol][i]; }

      const AnalysisWaveform * getCoherent(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return coherent[pol][filtered ? 1 : 0][i]; } 

      const AnalysisWaveform * getDeconvolved(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return deconvolved[pol][filtered ? 1: 0][i]; } 

      const AnalysisWaveform * getCoherentXpol(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return coherent_xpol[pol][filtered ? 1: 0][i]; } 

      const AnalysisWaveform * getDeconvolvedXpol(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return deconvolved_xpol[pol][filtered ? 1: 0][i]; } 

      const TGraphAligned * getCoherentPower(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return coherent_power[pol][filtered ? 1: 0][i]; } 

      const TGraphAligned * getDeconvolvedPower(AnitaPol::AnitaPol_t pol, int i, bool filtered = false) const { return deconvolved_power[pol][filtered ? 1: 0][i]; } 

      AnitaResponse::ResponseManager * getResponseManager() { return &responses; } 

      /* Return the summary. This only works in interactive mode. */ 
      const AnitaEventSummary* getSummary() const { return &last; }


      void drawSummary(TPad *chpol = 0, TPad * cvpol = 0, int draw_filtered = 0) const; 

      double getRoughPhi(AnitaPol::AnitaPol_t pol, int i) const { return rough_peaks[pol][i].first; }
      double getRoughTheta(AnitaPol::AnitaPol_t pol, int i) const { return -rough_peaks[pol][i].second; }

      void clearInteractiveMemory(double frac = 0.5) const; 
      
      void setDisallowedAntennas(ULong64_t hpol=0, ULong64_t vpol=0) {disallowedAnts[0] = hpol; disallowedAnts[1] = vpol; } 
      
      void setExcludePhiRange(double phiMin, double phiMax) {phiRange[0] = phiMin; phiRange[1] = phiMax; exclude = true; }
      void setExcludeThetaRange(double thetaMin, double thetaMax) {thetaRange[0] = thetaMin; thetaRange[1] = thetaMax; exclude = true; }
      void setExcludeThetaPhiRange(double thetaMin, double thetaMax, double phiMin, double phiMax) {thetaRange[0] = thetaMin; thetaRange[1] = thetaMax; phiRange[0] = phiMin; phiRange[1] = phiMax; exclude = true; }
      
      void setPhiRange(double phiMin, double phiMax) {phiRange[0] = phiMin; phiRange[1] = phiMax; exclude = false; }
      void setThetaRange(double thetaMin, double thetaMax) {thetaRange[0] = thetaMin; thetaRange[1] = thetaMax; exclude = false; }
      void setThetaPhiRange(double thetaMin, double thetaMax, double phiMin, double phiMax) {thetaRange[0] = thetaMin; thetaRange[1] = thetaMax; phiRange[0] = phiMin; phiRange[1] = phiMax; exclude = false; }
      void setTrackSource(double setLon, double setLat, double setAlt, double setdTheta = 2.5, double setdPhi = 5., bool blockOut = false) {sourceLon = setLon; sourceLat = setLat; sourceAlt = setAlt; dTheta = setdTheta; dPhi = setdPhi; exclude = blockOut; trackSource = true; }
      void setTrackSun(double setdTheta = 2.5, double setdPhi = 5., bool blockOut = false) {dTheta = setdTheta; dPhi = setdPhi; exclude = blockOut; trackSun = true; }
      void setTrackWAIS(double setdTheta = 2.5, double setdPhi = 5., bool blockOut = false) {sourceLon = AnitaLocations::getWaisLongitude(); sourceLat = AnitaLocations::getWaisLatitude(); sourceAlt = AnitaLocations::getWaisAltitude(); dTheta = setdTheta; dPhi = setdPhi; exclude = blockOut; trackSource = true; }
      void setTrackLDB(double setdTheta = 2.5, double setdPhi = 5., bool blockOut = false) {sourceLon = AnitaLocations::LONGITUDE_LDB; sourceLat = AnitaLocations::LATITUDE_LDB; sourceAlt = AnitaLocations::ALTITUDE_LDB; dTheta = setdTheta; dPhi = setdPhi; exclude = blockOut; trackSource = true; }
            void setExtraFilters(FilterStrategy* extra);
            void setExtraFiltersDeconvolved(FilterStrategy* extra);
      
  private:

      void fillWaveformInfo(const AnalysisWaveform * wf, const AnalysisWaveform * xpol_wf, const TGraph * power, AnitaEventSummary::WaveformInfo * info, AnitaPol::AnitaPol_t pol, double rms, double vpp = 0); 
      void fillPointingInfo(double rough_phi, double rough_theta, AnitaEventSummary::PointingHypothesis * point,
                            UsefulAdu5Pat * pat, double hwAngle, UShort_t triggered_sectors, UShort_t masked_sectors, UShort_t triggered_sectors_xpol, UShort_t masked_sectors_xpol); 
      void fillFlags(const FilteredAnitaEvent * fae, AnitaEventSummary* summary, UsefulAdu5Pat * pat); 
      void fillChannelInfo(const FilteredAnitaEvent* event, AnitaEventSummary* summary);

      gui::Map* correlation_maps[2]; 
      std::vector<gui::Map*>  zoomed_correlation_maps[2]; 
      std::vector<AnalysisWaveform *> coherent[2][2]; 
      std::vector<AnalysisWaveform *> deconvolved[2][2]; 
      std::vector<TGraphAligned *> coherent_power[2][2]; 
      std::vector<TGraphAligned *> deconvolved_power[2][2]; 
      std::vector<AnalysisWaveform *> coherent_xpol[2][2]; 
      std::vector<AnalysisWaveform *> deconvolved_xpol[2][2]; 
      std::vector<TGraphAligned *> coherent_power_xpol[2][2]; 
      std::vector<TGraphAligned *> deconvolved_power_xpol[2][2]; 
      std::vector<std::pair<double,double> > rough_peaks[2]; 
      AnitaEventSummary last; //used in interactive mode by drawSummary
      TGraph*  avg_spectra[2]; 

      const AnalysisConfig * cfg; 
      Correlator corr; 
      AnitaResponse::ResponseManager responses; 
      WaveformCombiner wfcomb; 
      WaveformCombiner wfcomb_xpol; 
      WaveformCombiner wfcomb_filtered; 
      WaveformCombiner wfcomb_xpol_filtered; 
      TH2D *zoomed; 
      double maprms; 
      FFTtools::DigitalFilter *  power_filter; 
      bool interactive; 
      bool interactive_deconvolved; 
      bool interactive_xpol_deconvolved; 
      ULong64_t disallowedAnts[2];
      double phiRange[2];
      double thetaRange[2];
      bool exclude;
      bool trackSource;
      double sourceLon;
      double sourceLat;
      double sourceAlt;
      bool trackSun;
      double dPhi;
      double dTheta;

      mutable std::vector<TObject*> delete_list; 
  };

}


#endif