AnitaEventCalibrator.h

#ifndef ANITAEVENTCALIBRATOR_H
#define ANITAEVENTCALIBRATOR_H

// ROOT
#include <TObject.h>
#include <TF1.h>
#include <TH1.h>
#include <TMath.h>
#include <TGraph.h>

#ifdef USE_FFT_TOOLS
#include "FFTtools.h"
#endif

// std lib
#include <fstream>
#include <map>
#include <bitset>

// Anita
#include "AnitaConventions.h"
#include "simpleStructs.h"
#include "AnitaClock.h"
#include "AnitaGeomTool.h"
#include "RingBuffer.h"
#include "RawAnitaHeader.h"



class TGraph;
class UsefulAnitaEvent;


class AnitaEventCalibrator : public TObject
{
  public:

  virtual ~AnitaEventCalibrator();
  static AnitaEventCalibrator* Instance(int version = 0); 

  Int_t calibrateUsefulEvent(UsefulAnitaEvent *eventPtr,
                 WaveCalType::WaveCalType_t calType);

  void guessRco(UsefulAnitaEvent* eventPtr); 
  void getTempFactors(UsefulAnitaEvent* eventPtr); 
  void updateTemperatureCorrection(UsefulAnitaEvent* eventPtr); 
  Int_t unwrapChannel(UsefulAnitaEvent* eventPtr, Int_t surf, Int_t chan, Int_t rco,
              Bool_t fApplyTempCorrection, Bool_t fAddPedestal,
              Double_t* voltsArray, Double_t* timeArray, Int_t* scaArray);
  void applyVoltageCalibration(UsefulAnitaEvent* eventPtr);
  void keepOnlySomeTimeAfterClockUptick(TGraph* grClock, Double_t deltaClockKeepNs);

  std::vector<Double_t> getClockAlignment(UsefulAnitaEvent* eventPtr,
                      Int_t numPoints[NUM_SURF],
                      Double_t volts[NUM_SURF][NUM_CHAN][NUM_SAMP],
                      Double_t times[NUM_SURF][NUM_SAMP]);
  std::vector<Double_t> getClockAlignment(UsefulAnitaEvent* eventPtr,
                      Int_t numPoints[NUM_SURF],
                      Double_t volts[NUM_SURF][NUM_CHAN][NUM_SAMP],
                      Double_t times[NUM_SURF][NUM_SAMP],
                      std::vector<Int_t> listOfClockNums);
  void deleteClockAlignmentTGraphs();
  void zeroMeanNonClockChannels();

  Double_t getTimeOfZeroCrossing(Double_t x1, Double_t y1, Double_t x2, Double_t y2);
  Int_t getTimeOfUpwardsClockTicksCrossingZero(Int_t numPoints, Int_t surf, Double_t* times,
                           Double_t* volts,
                           std::vector<Double_t>& timeZeroCrossings,
                           std::vector<Int_t>& sampZeroCrossings,
                           bool raiseFlagIfClocksAreWeird);

  void findExtremaSamples(Int_t length, Double_t* volts,
              std::vector<Int_t>& maximaSamps,
              std::vector<Int_t>& minimaSamps);


  void initializeVectors();


  // Primary event data: voltage and time arrays
  Double_t voltsArray[NUM_SURF][CHANNELS_PER_SURF][NUM_SAMP]; 
  Double_t timeArray[NUM_SURF][NUM_SAMP]; 
  Int_t numPointsArray[NUM_SURF]; 
  Int_t scaArray[NUM_SURF][NUM_SAMP]; 

  // Secondary event data
  std::vector<std::vector<RingBuffer> > clockPeriodRingBuffers; 
  // RingBuffer* clockPeriodRingBuffer; ///< Holds rolling average of temperature correction
  std::vector<Double_t> tempFactors; 


  // Int_t rcoArray[NUM_SURF]; ///< The output of AnitaEvenCalibrator::guessRco() goes here.
  // Double_t measuredClockPeriods[NUM_SURF][NUM_RCO][AnitaClock::maxNumZcs]; ///< For guessRco and getTempFactor
  std::vector<Int_t> rcoVector; 
  std::vector<std::vector<std::vector<Double_t> > > measuredClockPeriods;

  // Constants for timing/voltage calibration
  Double_t relativeCableDelays[NUM_SURF][NUM_CHAN][NUM_CHIP]; 
  Double_t relativePhaseCenterToAmpaDelays[NUM_SURF][NUM_CHAN]; 
  Double_t deltaTs[NUM_SURF][NUM_CHIP][NUM_RCO][NUM_SAMP]; 
  Double_t epsilons[NUM_SURF][NUM_CHIP][NUM_RCO]; 
  Double_t mvCalibVals[NUM_SURF][NUM_CHAN][NUM_CHIP]; 

  // Constants for calibration algorithms
  Double_t clockKeepTime[NUM_SURF][NUM_CHIP]; 
  Int_t firstHitBusRcoLatchLimit;


  std::vector<Int_t> defaultClocksToAlign; 
  std::vector<TGraph*> grClockInterps; 
  std::map<Double_t, TGraph*> grClock0s; 
  std::vector<TGraph*> grCorClock;
  std::vector<TGraph*> grClocks;


  std::vector<Double_t> clockAlignment;
  Double_t dtInterp; 
  Double_t nominalDeltaT; 
  Int_t fClockProblem; 
  Int_t fClockSpike; 


  //Ben Rotter's rfPower calibration :)
  Double_t convertRfPowTodBm(int surf, int chan, int adc);
  Double_t convertRfPowToKelvin(int surf, int chan, int adc);

  Double_t RfPowYInt[NUM_SURF][NUM_CHAN];
  Double_t RfPowSlope[NUM_SURF][NUM_CHAN];



  AnitaEventCalibrator(); // don't want multiple calibrators lying around for no reason

 private:

  // AnitaEventCalibrator(); // don't want multiple calibrators lying around for no reason
  void loadCalib(); 
  PedestalStruct_t fPedStruct; 
  ClassDef(AnitaEventCalibrator,0);

};


#endif //ANITAEVENTCALIBRATOR_H