SdCompositionParameters.h

Go to the documentation of this file.

#ifndef _SdCompParam_SdCompositionParameters_h_
#define _SdCompParam_SdCompositionParameters_h_

// Offline headers
#include <fwk/VModule.h>
#include <evt/Event.h>
#include <sevt/SEvent.h>
#include <sevt/Station.h>
#include <sevt/StationConstants.h>

// ROOT headers
#include <TGraphErrors.h>
#include <TF1.h>

// Standard c++ headers
#include <vector>


namespace SdCompParam {

  struct StationSdParameterData {
    unsigned int fStationId;
    double fCorrRisetime;
    double fCorrRisetimeError;
    double fDistance;
    double fDistanceError;
    double fSecZenith;
    double fPhotonBenchmark;
    double fSignal;
    unsigned short fRejectCode;
    bool fUseStation;
    int fSaturationFlag;
    int fRTCandidateFlag;
  };


  struct SdCompositionParameterResults {
    SdCompositionParameterResults();
    ~SdCompositionParameterResults();

    std::vector<StationSdParameterData*> fStationData;
    double fFitPar0;
    double fFitPar1;
    double fRisetime1000;
    double fRisetime1000Error;
    double fRisetime1000Chi2;
    double fRisetime1000NDF;
    double fXmax;
    double fXmaxErrorUp;
    double fXmaxErrorDown;
  };


  struct DeltaResults {
    DeltaResults();
    ~DeltaResults();

    std::vector<StationSdParameterData*> fStationData;
    double Delta;
  };


  class SdCompositionParameters : public fwk::VModule {

  public:
    SdCompositionParameters();
    virtual ~SdCompositionParameters();

    // Init, Run, and Finish functions
    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& theEvent);
    fwk::VModule::ResultFlag Finish();

    // Static public members for access outside this module
    static double fgRisetime;
    static double fgRisetimeError;
    static double fgRisetimeReducedChi2;
    static SdCompositionParameterResults* fgCompositionParameterResults;
    static DeltaResults* fgDeltaResults;

  protected:
    // Variables read from the xml file to configure the
    // risetime recalculation (if used)
    float fRiseTimeStartPercent;
    float fRiseTimeStopPercent;

  private:
    // Calculate the Risetime and return that value
    double FitEventRiseTime(evt::Event& event);
    double RecalculateRiseTime(sevt::Station& station);
    bool fUseDLECorrectedTrace;

    // Variables used for the riestime fit
    TFormula* fRTWeights;
    TFormula* fRTErrorFunc;
    unsigned int fRejectedStations;
    unsigned int fRTRejectedStations;
    unsigned int fLDFRejectedStations;

    // Variables read from the xml file to configure the risetime routines
    float fMinimumSignalForRiseTimeFit;    //Signal size in VEM
    float fMinimumDistanceForRiseTimeFit;  //Distance in meters
    float fMaximumDistanceForRiseTimeFit;  //Distance in meters
    float fDistanceToInterpolateFitResult; //Distance in meters to evaluate the fit at
    bool fIncludeSaturatedForRiseTimeFit;  //True or False
    bool fDoRiseTimeFit;
    bool fForceRiseTimeRecalculation;      //Don't trust others to calculate it
    char* fRTWeightingFunction;            //Function describing the
                                           //weight as a function of distance/signal size
    char* fRTErrorFunction;
    double fRTErrorFunctionParameterJa0;
    double fRTErrorFunctionParameterJa1;
    double fRTErrorFunctionParameterJb0;
    double fRTErrorFunctionParameterJb1;

    bool fDoCalculateLeedsDelta;
    bool fDoCalculateLDFParameters;
    double LeedsDeltaCalculation(evt::Event& event);
    double LDFParametersCalculation(evt::Event& event);
    double PhotonEnergyCalculation(evt::Event& event, double E_hadron, double secZenith);
    bool RTCandidateFlag(evt::Event& event, int saturationflag, double distance, bool usest, double rtcorr, double signal);
    bool SbCandidateFlag(int saturationflag, double distance, bool sat1000);
    bool SelectionDeltaRiseTime(int nst, double hadrenergy, bool doAltSel);
    bool SelectionRiseTime1000(int nst, int nstClose, double hadrenergy, bool doAltSel);
    bool SelectionLDFPar(int nst, evt::Event& event);
    int SaturationFlag(sevt::Station& station);
    char* fRisetimeBenchmarkFunction;
    char* fRisetimeBenchmarkParameterA;
    double fRisetimeBenchmarkParameterA_0;
    double fRisetimeBenchmarkParameterA_1;
    double fRisetimeBenchmarkParameterA_2;
    char* fRisetimeBenchmarkParameterB;
    double fRisetimeBenchmarkParameterB_0;
    double fRisetimeBenchmarkParameterB_1;
    double fRisetimeBenchmarkParameterB_2;
    char* fRisetimeAzimuthCorrectionFunction;
    char* fRisetimeDistanceCorrectionFunction;
    char* fRisetimeZenithCorrectionFunction1;
    double fRisetimeZenithCorrectionFunction1Parameterl0;
    double fRisetimeZenithCorrectionFunction1Parameterl1;
    double fRisetimeZenithCorrectionFunction1Parameterl2;
    char* fRisetimeZenithCorrectionFunction2;
    double fRisetimeZenithCorrectionFunction2Parameterm0;
    double fRisetimeZenithCorrectionFunction2Parameterm1;
    double fRisetimeZenithCorrectionFunction2Parameterm2;
    double fLDFParametersOptimumDistance;
    double fLDFParametersScaleDistance;
    bool fCut1000;
    TFormula* fRTBenchmark;
    TFormula* fRTBenchmarkParameterA;
    TFormula* fRTBenchmarkParameterB;
    TFormula* fRTAzimuthCorrections;
    TFormula* fRTDistanceCorrections;
    TFormula* fRTZenithCorrections1;
    TFormula* fRTZenithCorrections2;
    double secZenith;
    double recEnergy;
    // Derived variables
    sevt::StationConstants::SignalComponent fComponent;

    REGISTER_MODULE("SdCompositionParameters", SdCompositionParameters);

  };

}


#endif