AnitaDataset.h

#ifndef ANITA_DATASET_H
#define ANITA_DATASET_H

#include <vector>
#include "AnitaConventions.h"
#include "TString.h"
#include "TRandom3.h"

class RawAnitaHeader;
class TTree;
class Adu5Pat;
class UsefulAnitaEvent;
class RawAnitaEvent;
class CalibratedAnitaEvent;
class PrettyAnitaHk;
class TFile;
class TurfRate;
class TCut;
class TEventList;
class SurfHk;
class TruthAnitaEvent;

class AnitaDataset
{
  public:


  // All the blinding options.
  // The plan is to have each one represented by a bit so multiple strategies can be set at the same time.
  // Any output files should probably save the blinding strategy to the tree.
    enum BlindingStrategy
    {
      kNoBlinding = 0x00, 
      kInsertedVPolEvents = 0x01, 
      kInsertedHPolEvents = 0x02, 
      kRandomizePolarity = 0x04, 
      kDefault = kNoBlinding
    }; 


    // various data directories that might be searched by AnitaDataset
    // Note that ANITA_ROOT_DATA is reverted to searched if none of the others work
    enum DataDirectory
    {
      ANITA_ROOT_DATA = -1, 
      ANITA_MC_DATA= 0, 
      ANITA1_ROOT_DATA=1,
      ANITA2_ROOT_DATA=2,
      ANITA3_ROOT_DATA=3, 
      ANITA4_ROOT_DATA=4
    }; 

  static TString getDescription(BlindingStrategy strat); 


   BlindingStrategy setStrategy(BlindingStrategy strat);


   BlindingStrategy getStrategy();

  inline TString describeCurrentStrategy(){
    return getDescription(getStrategy());
  }


   static int getRunContainingEventNumber(UInt_t eventNumber);


    static const char * getDataDir(DataDirectory dir = ANITA_ROOT_DATA);

    static int getRunAtTime(double t);

    static bool isKnownHiCalEvent(UInt_t eventNumber, Int_t anita=AnitaVersion::get());


    AnitaDataset (int run, bool decimated = false, WaveCalType::WaveCalType_t cal = WaveCalType::kDefault, 
                  DataDirectory dir = ANITA_ROOT_DATA , BlindingStrategy strat = AnitaDataset::kDefault);

    void setCalType(WaveCalType::WaveCalType_t cal) { fCalType = cal; }

    virtual ~AnitaDataset();


    bool loadRun(int run, bool decimated = false, DataDirectory dir  = ANITA_ROOT_DATA );

    int getEvent(int eventNumber, bool quiet = false);

    int getEntry(int entryNumber);

    // returns the currently selected entry
    int current() { return fDecimated ? fDecimatedEntry : fWantedEntry; }

    int next() { return getEntry(fDecimated ? fDecimatedEntry +1  : fWantedEntry+1); }

    int previous() { return getEntry(fDecimated ? fDecimatedEntry - 1 : fWantedEntry-1); }

    int first() { return getEntry(0); }

    int last() { return getEntry(N()-1); }

    int N() const;


    int firstEvent();

    int nextEvent();

    int previousEvent();

    int lastEvent();

    int nthEvent(int i);

    int nextMinBiasEvent();

    int previousMinBiasEvent();

    int setCut(const TCut & cut);

    int NInCut() const;

    int firstInCut();

    int lastInCut();

    int nextInCut();

    int previousInCut();

    int nthInCut(int i);

    int setPlaylist(const char* playlist);

    int NInPlaylist() const;

    int firstInPlaylist();

    int lastInPlaylist();

    int nextInPlaylist();

    int previousInPlaylist();

    int nthInPlaylist(int i);

     virtual UsefulAnitaEvent * useful(bool force_reload = false);


    RawAnitaEvent * raw(bool force_reload = false);

    CalibratedAnitaEvent * calibrated(bool force_reload = false);


    Adu5Pat * gps(bool force_reload = false);

    PrettyAnitaHk * hk(bool force_reload = false);

    virtual RawAnitaHeader * header(bool force_reload = false);


    TurfRate * turf(bool force_reload = false);

    SurfHk * surf(bool force_reload = false);


    TruthAnitaEvent * truth(bool force_reload = true); 
    
    std::vector<Double_t>* RcoInfo(bool force_reload = false);
    std::vector<Double_t>* ClockPhiInfo(bool force_reload = false);
    std::vector<Double_t>* TempFactorInfo(bool force_reload = false);
    Int_t ClockProblemInfo(bool force_reload = false);
    Int_t ClockSpikeInfo(bool force_reload = false);
    Int_t RFSpikeInfo(bool force_reload = false);

    bool fRunLoaded;

    int getCurrRun() { return currRun; };

    /* Wraps the random number generator for polarity inversion so it is derministic regardless of event processing order */
    bool maybeInvertPolarity(UInt_t eventNumber);

    /* Where was HiCal at a particular time?*/
    static void hiCal(UInt_t unixTime, Double_t& longitude,  Double_t& latitude, Double_t& altitude);

    /* Where was hical? Uses the current header realTime*/ 
    void hiCal(Double_t& longitude,  Double_t& latitude, Double_t& altitude);

  protected:
    void unloadRun();
    TTree * fHeadTree;
    TTree * fDecimatedHeadTree; //only used when using decimated
    Long64_t * fIndices;
    Long64_t fIndex;
    RawAnitaHeader * fHeader;
    TTree *fEventTree;
    TTree* fCalibInfoTree;
    CalibratedAnitaEvent * fCalEvent;
    RawAnitaEvent * fRawEvent;
    UsefulAnitaEvent * fUseful;
    std::vector<Double_t>* fRcoInfo;
    std::vector<Double_t>* fClockPhiInfo;
    std::vector<Double_t>* fTempFactorInfo;
    Int_t fClockProblemInfo;
    Int_t fClockSpikeInfo;
    Int_t fRFSpikeInfo;
    Bool_t fUsefulDirty;
    Bool_t fCalDirty;  // used only with raw data
    Bool_t fGpsDirty;  // used only with gpsFile data
    TTree* fGpsTree;
    Adu5Pat * fGps;
    TTree* fHkTree;
    PrettyAnitaHk * fHk;

    TTree * fTurfTree;
    TurfRate * fTurf;
    Bool_t fTurfDirty;

    TTree * fSurfTree;
    SurfHk * fSurf;
    Bool_t fSurfDirty;

    TTree * fTruthTree; 
    TruthAnitaEvent * fTruth;


    /* place to store the current run but that can't be confusingly changed */
    int currRun;

    Long64_t fWantedEntry;
    Long64_t fDecimatedEntry;
    Bool_t fHaveGpsEvent;
    Bool_t fHaveCalibFile;
    Bool_t fHaveCalibInfo;
    WaveCalType::WaveCalType_t fCalType;
    std::vector<TFile *> filesToClose;
    bool fDecimated;
    TEventList * fCutList;
    int fCutIndex;

    static void loadRunToEv(int anita); // read runToEvA*.txt
    static void loadHiCalGps(); 
    int loadPlaylist(const char* playlist);
    int fPlaylistIndex;
    std::vector<std::vector<long> > fPlaylist;
    int getPlaylistRun() { return fPlaylist[fPlaylistIndex][0]; }
    Long64_t getPlaylistEvent() { return fPlaylist[fPlaylistIndex][1]; }


    /* Blinding stuff */ 
    void zeroBlindPointers();
    void loadBlindTrees();

    BlindingStrategy theStrat; 
    TRandom3 fRandy; 

    bool loadedBlindTrees; 
    Int_t needToOverwriteEvent(AnitaPol::AnitaPol_t pol, UInt_t eventNumber);
    void overwriteHeader(RawAnitaHeader* header, AnitaPol::AnitaPol_t pol, Int_t fakeTreeEntry);
    void overwriteEvent(UsefulAnitaEvent* useful, AnitaPol::AnitaPol_t pol, Int_t fakeTreeEntry);

    // fake things
    TFile* fBlindFile; 
    TTree* fBlindEventTree[AnitaPol::kNotAPol]; 
    TTree* fBlindHeadTree[AnitaPol::kNotAPol]; 

    UsefulAnitaEvent* fBlindEvent[AnitaPol::kNotAPol]; 
    RawAnitaHeader* fBlindHeader[AnitaPol::kNotAPol]; 

    // Here we have a set of three vectors that should all be the same length as the elements of each match up.
    // They are filled in loadBlindTrees
    std::vector<UInt_t> eventsToOverwrite;
    std::vector<AnitaPol::AnitaPol_t> polarityOfEventToInsert;
    std::vector<Int_t> fakeTreeEntries;

    DataDirectory datadir; 

  
};

// define the bitwise or operator | to combine blinding strategies
inline AnitaDataset::BlindingStrategy operator|(AnitaDataset::BlindingStrategy strat1,  AnitaDataset::BlindingStrategy strat2){
  return static_cast<AnitaDataset::BlindingStrategy>(static_cast<UInt_t>(strat1) | static_cast<UInt_t>(strat2));
}
// define the bitwise and opterator & to decode the blinding strategies
inline AnitaDataset::BlindingStrategy operator&(AnitaDataset::BlindingStrategy strat1,  AnitaDataset::BlindingStrategy strat2){
  return static_cast<AnitaDataset::BlindingStrategy>(static_cast<UInt_t>(strat1) & static_cast<UInt_t>(strat2));
}



#endif