AnalysisReco.h

#ifndef ANALYSIS_RECO_H
#define ANALYSIS_RECO_H

#include "AnitaEventReconstructor.h"
#include "InterferometricMap.h"
#include "InterferometryCache.h"
#include "CrossCorrelator.h"
#include "AnalysisSettings.h"
#include <list>

namespace AnitaResponse {
  class DeconvolutionMethod;
  class ResponseManager;
}
class NoiseMonitor;
class TruthAnitaEvent;

namespace Acclaim
{

  class InterferometryCache;
  
  class AnalysisReco : public TObject {

  public:
    friend class InterferometryCache; 

    enum DrawDomain{
      kTimeDomain = 0,
      kFreqDomain = 1,
      kStokesParams = 2,
    };

    AnalysisReco();

    virtual ~AnalysisReco();

    void process(const FilteredAnitaEvent * fEv, AnitaEventSummary * sum, NoiseMonitor* noiseMonitor=NULL, TruthAnitaEvent* truth = NULL);

    Double_t getDeltaTExpected(AnitaPol::AnitaPol_t pol, Int_t ant1, Int_t ant2, Double_t phiWave, Double_t thetaWave) const;


    Double_t getDeltaTExpected(AnitaPol::AnitaPol_t pol, Int_t ant, Double_t phiWave, Double_t thetaWave) const;

    Double_t relativeOffAxisDelay(AnitaPol::AnitaPol_t pol, Int_t ant1, Int_t ant2, Double_t phiDeg) const;

    Double_t singleAntennaOffAxisDelay(Double_t deltaPhiDeg) const;

    void drawSummary(TPad* wholePad, AnitaPol::AnitaPol_t pol);

    InterferometricMap* getMap(AnitaPol::AnitaPol_t pol);

    InterferometricMap* getZoomMap(AnitaPol::AnitaPol_t pol, UInt_t peakInd=0);

    void reconstruct(AnitaPol::AnitaPol_t pol, const Adu5Pat* pat = NULL);

    void reconstructZoom(AnitaPol::AnitaPol_t pol, Int_t peakIndex, Double_t zoomCenterPhiDeg, Double_t zoomCenterThetaDeg, const Adu5Pat* pat = NULL);


    AnalysisWaveform* coherentlySum(const FilteredAnitaEvent* fEv, AnitaPol::AnitaPol_t pol, const std::vector<Int_t>& theAnts, Double_t peakPhiDeg, Double_t peakThetaDeg, Double_t* biggestPeakToPeak=NULL ,double* forceT0 = NULL);


    AnalysisWaveform* coherentlySum(std::vector<const AnalysisWaveform*>& waves, std::vector<Double_t>& dts, const double* forceT0 = NULL);



    static Int_t directlyInsertGeometry(TString pathToLindasFile, AnitaPol::AnitaPol_t pol);

    void insertPhotogrammetryGeometry();

    AnalysisWaveform* getCoherentFiltered(AnitaPol::AnitaPol_t pol, Int_t peakInd=0, bool xPol=false);


    AnalysisWaveform* getCoherent(AnitaPol::AnitaPol_t pol, Int_t peakInd=0, bool xPol=false);


    AnalysisWaveform* getDeconvolved(AnitaPol::AnitaPol_t pol, Int_t peakInd=0, bool xPol=false);


    AnalysisWaveform* getDeconvolvedFiltered(AnitaPol::AnitaPol_t pol, Int_t peakInd=0, bool xPol=false);


    FilteredAnitaEvent* getEvMin();


    FilteredAnitaEvent* getEvMinDeco();


    FilteredAnitaEvent* getEvDeco();


    void directionAndAntennasToDeltaTs(const std::vector<Int_t>& theAnts, AnitaPol::AnitaPol_t pol,
                       Double_t peakPhiDeg, Double_t peakThetaDeg, std::vector<double>& dts);



    static void setTriggerInfoFromPeakPhi(const RawAnitaHeader* header, AnitaPol::AnitaPol_t pol,
                      Int_t peakPhiSector, AnitaEventSummary::PointingHypothesis& peak);



    static void fillChannelInfo(const FilteredAnitaEvent* fEv, AnitaEventSummary* sum);


    void fillPowerFlags(const FilteredAnitaEvent* fEv, AnitaEventSummary::EventFlags& flags);


    const std::vector<int>& phiSectorToCoherentAnts(int peakPhiSector){return fPhiSectorToAnts[peakPhiSector];}


    void wavesInCoherent(std::vector<const AnalysisWaveform*>& waves, std::vector<Double_t>& dts, std::vector<TGraphAligned*>& grs);


    CrossCorrelator* getCrossCorrelator(){return fCrossCorr;}

    const AnitaEventSummary& lastSummary(){return fSummary;}

  protected:

    void initializeInternals();

    InterferometricMap* coarseMaps[AnitaPol::kNotAPol]; 
    InterferometricMap* fineMaps[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 


    size_t checkWavesAndDtsMatch(std::vector<const AnalysisWaveform*>& waves, std::vector<Double_t>& dts);

    void fillWaveformInfo(AnitaPol::AnitaPol_t pol, Int_t peakInd, AnitaEventSummary::WaveformInfo& info, const FilteredAnitaEvent* fEv,
              AnalysisWaveform** waveStore, InterferometricMap* h, NoiseMonitor* noiseMonitor,
              std::vector<double>& I, std::vector<double>& Q, std::vector<double>& U, std::vector<double>& V);


    void chooseAntennasForCoherentlySumming(int coherentDeltaPhi);

    void nicelyDeleteInternalFilteredEvents();


    std::vector<Double_t> fRArray[AnitaPol::kNotAPol]; 
    std::vector<Double_t> fPhiArrayDeg[AnitaPol::kNotAPol]; 
    std::vector<Double_t> fZArray[AnitaPol::kNotAPol]; 

    AnalysisWaveform* fCoherentFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol][AnitaPol::kNotAPol]; 
    AnalysisWaveform* fCoherent[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol][AnitaPol::kNotAPol] ; 
    AnalysisWaveform* fDeconvolved[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol][AnitaPol::kNotAPol]; 
    AnalysisWaveform* fDeconvolvedFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol][AnitaPol::kNotAPol]; 
    std::vector<Int_t> fPhiSectorToAnts[NUM_PHI]; 

    AnitaEventSummary fSummary; 
    CrossCorrelator* fCrossCorr; 
    bool fSpawnedCrossCorrelator; 
    InterferometryCache fDtCache; 

    FilterStrategy* fMinFilter; 
    FilterStrategy* fMinDecoFilter; 

    FilteredAnitaEvent* fEvMin; 
    FilteredAnitaEvent* fEvMinDeco; 
    FilteredAnitaEvent* fEvDeco; 

    UInt_t fCurrentEventNumber; 
    Int_t fCurrentRun; 

    std::vector<double> f_dICoherentFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dQCoherentFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dUCoherentFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dVCoherentFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dIDeconvolvedFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dQDeconvolvedFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dUDeconvolvedFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 
    std::vector<double> f_dVDeconvolvedFiltered[AnitaPol::kNotAPol][AnitaEventSummary::maxDirectionsPerPol]; 

    ANALYSIS_SETTING(Int_t, Debug);

    ANALYSIS_SETTING(Int_t, CoherentDeltaPhi);
    Int_t fLastCoherentDeltaPhi; 


    ANALYSIS_SETTING(Int_t, WhichResponseDir);

    ANALYSIS_SETTING(Int_t, UseOffAxisDelay);


    ANALYSIS_SETTING(Int_t, ResponseNPad);

    ANALYSIS_SETTING(Int_t, NumPeaks);

    ANALYSIS_SETTING(Double_t, CoherentDtNs);

    ANALYSIS_SETTING(Double_t, SlopeFitStartFreqGHz);

    ANALYSIS_SETTING(Double_t, SlopeFitEndFreqGHz);

    
    ANALYSIS_SETTING(Double_t, MeanPowerFlagLowFreqGHz);

    ANALYSIS_SETTING(Double_t, MeanPowerFlagHighFreqGHz);

    ANALYSIS_SETTING(Int_t, FillChannelInfo);

    ANALYSIS_SETTING(Int_t, FillSpectrumInfo);

    ANALYSIS_SETTING(Int_t, FillUnfiltered);


    ANALYSIS_SETTING(Int_t, InstantaneousStokes);











    ANALYSIS_SETTING(Int_t, DrawNPeaks)


    
    ENUM_ANALYSIS_SETTING(DrawDomain, DrawDomain)


    ANALYSIS_SETTING(Int_t, DrawCoherent)


    ANALYSIS_SETTING(Int_t, DrawDedispersed)


    ANALYSIS_SETTING(Int_t, DrawXPol)


    ANALYSIS_SETTING(Int_t, DrawXPolDedispersed)





    ClassDef(AnalysisReco, 0)

  };

}


#endif