d4/dca/_useful_anita_event_8h_source.html

 #ifndef USEFULANITAEVENT_H
 #define USEFULANITAEVENT_H

 //Includes
 #include <TObject.h>
 #include "RawAnitaEvent.h"
 #include "AnitaConventions.h"

 #include <map>
 #include <vector>

 class TGraph;
 class AnitaEventCalibrator;
 class PrettyAnitaHk;
 class RawAnitaHeader;
 class CalibratedAnitaEvent;


 class UsefulAnitaEvent: public RawAnitaEvent
 {

  public:
   UsefulAnitaEvent();
   UsefulAnitaEvent(CalibratedAnitaEvent *calibratedPtr, WaveCalType::WaveCalType_t calType=WaveCalType::kDefault);
   //  UsefulAnitaEvent(CalibratedAnitaEvent *calibratedPtr, WaveCalType::WaveCalType_t calType, RawAnitaHeader* theHd); ///< Assignment constructor from a CalibratedAnitaEvent
   UsefulAnitaEvent(RawAnitaEvent *eventPtr,WaveCalType::WaveCalType_t calType, PrettyAnitaHk *theHk=0);
   UsefulAnitaEvent(RawAnitaEvent *eventPtr,WaveCalType::WaveCalType_t calType, RawAnitaHeader *theHd);
   UsefulAnitaEvent(RawAnitaEvent *eventPtr,WaveCalType::WaveCalType_t calType, Double_t surfTemp);
   UsefulAnitaEvent(RawAnitaEvent *eventPtr,WaveCalType::WaveCalType_t calType, RawAnitaHeader *theHd, std::vector<Double_t>* rcoInfo, std::vector<Double_t>* clockPhiInfo, std::vector<Double_t>* tempFactorInfo, Int_t clockProblemInfo, Int_t clockSpikeInfo, Int_t rfSpikeInfo);
   virtual ~UsefulAnitaEvent();
   int calibrateEvent(WaveCalType::WaveCalType_t calType);

   //Generally useful function
   static int getChanIndex(int surf, int chan)
      {return chan+(CHANNELS_PER_SURF*surf);}


   TGraph *getGraphFromSurfAndChan(int surf, int chan) const;
   TGraph *getGraph(int chanIndex) const;
   TGraph *getGraph(int ant, AnitaPol::AnitaPol_t pol) const;
   TGraph *getGraph(AnitaRing::AnitaRing_t ring,
            int phi,
            AnitaPol::AnitaPol_t pol) const;
   TGraph *getDeconvolvedALFA(); //
   Int_t guessRco(int chanIndex);
   Int_t getRcoCorrected(int chanIndex);
   // Double_t getTempCorrectionFactor(); ///< Returns the temperature correction factor (or guesses at it using clock periods if necessary)
   // void analyseClocksForGuesses();
   // void analyseClocksForTempGuessBen();


   // std::vector<std::vector<Double_t> > getNeighbouringClockCorrelations(Double_t lowPassClockFilterFreq, Int_t giveGraphsToInputArrays, TGraph* grInterpClocksArray[NUM_SURF], TGraph* grCorClocksArray[NUM_SURF][2]);
   // std::vector<std::vector<Double_t> > getNeighbouringClockCorrelations2(bool writeGraphs);

   std::vector<Double_t> getClockAlignment(std::vector<Int_t> listOfClockNums);
   Int_t checkIfTreatingCalibratedEventAsRawEvent(RawAnitaEvent* rawEventPtr, const char* funcName);


   //The calibrated numbers
   Int_t fFromCalibratedAnitaEvent;
   UInt_t fC3poNum;
   Int_t gotCalibTemp;
   Double_t calibTemp;
   WaveCalType::WaveCalType_t fCalType;
   int fNumPoints[NUM_DIGITZED_CHANNELS];
   double fVolts[NUM_DIGITZED_CHANNELS][NUM_SAMP];
   double fTimes[NUM_DIGITZED_CHANNELS][NUM_SAMP];
   int fCapacitorNum[NUM_DIGITZED_CHANNELS][NUM_SAMP];
   UInt_t fLastEventGuessed;
   Int_t fRcoArray[NUM_SURF];
   Double_t fTempFactorGuesses[NUM_SURF];
   Int_t fClockProblem;
   Int_t fClockSpike;
   Int_t fRFSpike;
   Double_t fClockPhiArray[NUM_SURF];
   std::vector<int> SpikeyRFChannelList;

   Bool_t getAlfaFilterFlag();
   Bool_t setAlfaFilterFlag(Bool_t newBoolianFlag);

  private:
   Bool_t fFilterAlfaChannel;

   ClassDef(UsefulAnitaEvent,7);
 };


 #endif //USEFULANITAEVENT_H
UsefulAnitaEvent::fTempFactorGuesses
Double_t fTempFactorGuesses[12]
A holder variable to cling on to the temperature correction factor that we are guessing at...
Definition: UsefulAnitaEvent.h:84

UsefulAnitaEvent::checkIfTreatingCalibratedEventAsRawEvent
Int_t checkIfTreatingCalibratedEventAsRawEvent(RawAnitaEvent *rawEventPtr, const char *funcName)
Prints a verbose error message if you&#39;re calling the wrong constructor type.
Definition: UsefulAnitaEvent.cxx:287

UsefulAnitaEvent::fLastEventGuessed
UInt_t fLastEventGuessed
Internal variable to see if we&#39;ve already tried to guess the RCO and temp correction factors for this...
Definition: UsefulAnitaEvent.h:82

UsefulAnitaEvent::getRcoCorrected
Int_t getRcoCorrected(int chanIndex)
Returns firmware RCO after correcting for latch delay (and factor of -1 for different definitions of ...
Definition: UsefulAnitaEvent.cxx:252

WaveCalType::WaveCalType_t
enum WaveCalType::EWaveCalType WaveCalType_t
The calibration enumeration type.

PrettyAnitaHk
PrettyAnitaHk – The prettified ANITA Hk.
Definition: PrettyAnitaHk.h:22

UsefulAnitaEvent::fVolts
double fVolts[12 *9][260]
Array of unwrapped (unless kNoCalib) voltages for each channel.
Definition: UsefulAnitaEvent.h:79

UsefulAnitaEvent::fNumPoints
int fNumPoints[12 *9]
Number of poins per channel.
Definition: UsefulAnitaEvent.h:78

UsefulAnitaEvent::UsefulAnitaEvent
UsefulAnitaEvent()
Default constructor.
Definition: UsefulAnitaEvent.cxx:28

UsefulAnitaEvent::gotCalibTemp
Int_t gotCalibTemp
Flag to check if we are using the temperature calibration.
Definition: UsefulAnitaEvent.h:75

UsefulAnitaEvent::getClockAlignment
std::vector< Double_t > getClockAlignment(std::vector< Int_t > listOfClockNums)
For calibration.
Definition: UsefulAnitaEvent.cxx:274

RawAnitaHeader
RawAnitaHeader – The Raw ANITA Event Header.
Definition: RawAnitaHeader.h:22

AnitaEventCalibrator
AnitaEventCalibrator – The ANITA Event Calibrator.
Definition: AnitaEventCalibrator.h:46

UsefulAnitaEvent::getGraphFromSurfAndChan
TGraph * getGraphFromSurfAndChan(int surf, int chan) const
Returns a voltage-time waveform for given SURF and channel.
Definition: UsefulAnitaEvent.cxx:178

UsefulAnitaEvent::calibrateEvent
int calibrateEvent(WaveCalType::WaveCalType_t calType)
Work horse member function called by constructor.
Definition: UsefulAnitaEvent.cxx:171

AnitaRing::AnitaRing_t
enum AnitaRing::EAnitaRing AnitaRing_t
Ring enumeration.

WaveCalType::kDefault
What you should call for analysis work.
Definition: AnitaConventions.h:43

UsefulAnitaEvent::~UsefulAnitaEvent
virtual ~UsefulAnitaEvent()
Destructor.
Definition: UsefulAnitaEvent.cxx:167

UsefulAnitaEvent::getAlfaFilterFlag
Bool_t getAlfaFilterFlag()
a list to store the spikey RF channel.
Definition: UsefulAnitaEvent.cxx:321

UsefulAnitaEvent::fClockProblem
Int_t fClockProblem
Flag raised if more than 4 upgoing zero crossings in clock, won&#39;t update temp correction. RCO guessing may also be negatively affected by this.
Definition: UsefulAnitaEvent.h:85

UsefulAnitaEvent::fCapacitorNum
int fCapacitorNum[12 *9][260]
Array of capacitor numbers.
Definition: UsefulAnitaEvent.h:81

UsefulAnitaEvent::getGraph
TGraph * getGraph(int chanIndex) const
Returns a voltage-time waveform for given channel index.
Definition: UsefulAnitaEvent.cxx:183

UsefulAnitaEvent
UsefulAnitaEvent – The Calibrated Useful Anita Event object.
Definition: UsefulAnitaEvent.h:31

UsefulAnitaEvent::calibTemp
Double_t calibTemp
Value for the temperature calibration.
Definition: UsefulAnitaEvent.h:76

CalibratedAnitaEvent
CalibratedAnitaEvent – The Calibrated Calibrated Anita Event object.
Definition: CalibratedAnitaEvent.h:28

UsefulAnitaEvent::fC3poNum
UInt_t fC3poNum
Used to monitor the clock period.
Definition: UsefulAnitaEvent.h:74

UsefulAnitaEvent::getChanIndex
static int getChanIndex(int surf, int chan)
Utility function.
Definition: UsefulAnitaEvent.h:46

UsefulAnitaEvent::fRFSpike
Int_t fRFSpike
Flag raised if the ADC value is too large or small in RF.
Definition: UsefulAnitaEvent.h:87

UsefulAnitaEvent::fCalType
WaveCalType::WaveCalType_t fCalType
The calibration type requested.
Definition: UsefulAnitaEvent.h:77

UsefulAnitaEvent::fRcoArray
Int_t fRcoArray[12]
An array to store the guessed at RCO values.
Definition: UsefulAnitaEvent.h:83

UsefulAnitaEvent::guessRco
Int_t guessRco(int chanIndex)
Looks at clock channel to try and guess which RCO phase we are in.
Definition: UsefulAnitaEvent.cxx:237

UsefulAnitaEvent::fFromCalibratedAnitaEvent
Int_t fFromCalibratedAnitaEvent
Flag used in determining whether the event came from a CalibratedAnitaEvent.
Definition: UsefulAnitaEvent.h:73

AnitaPol::AnitaPol_t
enum AnitaPol::EAnitaPol AnitaPol_t
Polarisation enumeration.

UsefulAnitaEvent::fClockPhiArray
Double_t fClockPhiArray[12]
An array to store the derived clock calibration numbers (from aligning the clocks) ...
Definition: UsefulAnitaEvent.h:88

UsefulAnitaEvent::fClockSpike
Int_t fClockSpike
Flag raised if the ADC value is too large or small in clock.
Definition: UsefulAnitaEvent.h:86

UsefulAnitaEvent::fTimes
double fTimes[12 *9][260]
Array of unwrapped (unless kNoCalib) times for each channel.
Definition: UsefulAnitaEvent.h:80

RawAnitaEvent
RawAnitaEvent – The Raw ANITA Event Data.
Definition: RawAnitaEvent.h:22