ShowerMRecData.h

Go to the documentation of this file.

#ifndef _evt_ShowerMRecData_h_
#define _evt_ShowerMRecData_h_

#include <vector>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/LameShadowPtr_fwd.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/ShadowPtr.h>
#include <sevt/PlaneFrontRecData.h>

namespace evt {

  class ShowerRecData;

  class ShowerMRecData {
  public:
    const utl::TabulatedFunctionErrors& GetMLDF() const { return *fMLDF; }
    utl::TabulatedFunctionErrors& GetMLDF() { return *fMLDF; }   
    bool HasMLDF() const { return bool(fMLDF); }
    void MakeMLDF();
    double GetMLDFChi2() const { return fMLDFChi2; }
    double GetMLDFNdof() const { return fMLDFNdof; }
    double GetMLDFLikelihood() const { return fMLDFLikelihood; }
    double GetAlpha() const { return fAlpha; }
    double GetAlphaError() const { return fAlphaError; }
    double GetBeta() const { return fBeta; }
    double GetBetaError() const { return fBetaError; }
    double GetBetaSystematics() const { return fBetaSystematics; }
    double GetGamma() const { return fGamma; }
    double GetGammaError() const { return fGammaError; }
    double GetR0() const { return fR0; }
    double GetR0Error() const { return fR0Error; }
    double GetNMuRef() const { return fNMuRef; }
    double GetNMuRefError() const { return fNMuRefError; }
    double GetNMuRefSystematics() const { return fNMuRefSystematics; }

    void SetAlpha(const double alpha, const double error) 
    { fAlpha = alpha; fAlphaError = error; }
    void SetBeta(const double beta, const double error=0) 
    { fBeta = beta; fBetaError = error; }
    void SetBetaSystematics(const double BetaSys) { fBetaSystematics = BetaSys; }
    void SetGamma(const double gamma, const double error) 
    { fGamma = gamma; fGammaError = error; }
    void SetR0(const double r0, const double error) 
    { fR0 = r0; fR0Error = error; }
     void SetNMuRef(const double NMuRef, const double error) 
    { fNMuRef = NMuRef; fNMuRefError = error; }
    void SetNMuRefSystematics(const double NMuRefSys) 
    { fNMuRefSystematics = NMuRefSys; }
    void SetMLDFChi2(const double chi2, const double ndof) 
    { fMLDFChi2 = chi2; fMLDFNdof = ndof; }
    void SetMLDFLikelihood(const double likelihood) 
    { fMLDFLikelihood = likelihood; }

    void SetReferenceDistance( double rd ) { fReferenceDistance = rd ;}
    double GetReferenceDistance() const { return fReferenceDistance; }

    void SetCorePosition(const utl::Point& core) { fCore = core; }
    const utl::Point& GetCorePosition() const { return fCore; }

    void SetBarycenter(const utl::Point& bary) { fBarycenter = bary; }
    const utl::Point& GetBarycenter() const { return fBarycenter; }  

    void SetCoreError(const utl::Vector& coreerr) { fCoreError = coreerr; }
    const utl::Vector& GetCoreError() const { return fCoreError; }

    void SetCorrelationXY( double corr ) { fCorrelationXY = corr; }
    double GetCorrelationXY() const { return fCorrelationXY; }

    const utl::Vector& GetAxis() const { return fAxis; }
    void SetAxis(const utl::Vector& axis) { fAxis = axis; }

    const utl::Vector& GetReferenceAxis() const { return fReferenceAxis; }
    void SetReferenceAxis(const utl::Vector& axis) { fReferenceAxis = axis; }

    const utl::Point& GetReferenceCorePosition() const { return fReferenceCore; }
    void SetReferenceCorePosition(const utl::Point& core) { fReferenceCore = core; }

    double GetCurvature() const { return fCurvature; }
    double GetCurvatureError() const { return fCurvatureError; }
    void SetCurvature(const double curvature, const double error)
    { fCurvature = curvature; fCurvatureError = error; }

    const utl::TimeStamp& GetCoreTime() const { return fCoreTime; }
    const utl::TimeInterval& GetCoreTimeError() const { return fCoreTimeError; }
    void SetCoreTime(const utl::TimeStamp& coreTime, const utl::TimeInterval& coreTimeErr)
    { fCoreTime = coreTime; fCoreTimeError = coreTimeErr; }

    double GetTimeResidualMean() const { return fTimeResidualMean; }
    void SetTimeResidualMean(const double mean) { fTimeResidualMean = mean; }

    double GetTimeResidualSpread() const { return fTimeResidualSpread; }
    void SetTimeResidualSpread(const double spread) { fTimeResidualSpread = spread; }

    double GetAngleChi2() const { return fAngleChi2; }
    unsigned int GetAngleNdof() const { return fAngleNdof; }
    void SetAngleChi2(const double chi2, const unsigned int ndof)
    { fAngleChi2 = chi2; fAngleNdof = ndof; }

    // Angle between the axis reconstructed by the MD and the SD
    void SetMdSdAngle(double a) { fMdSdAngle=a; } 
    double GetMdSdAngle() const { return fMdSdAngle; }  

    void SetThetaError(double error) { fThetaError=error; }
    double GetThetaError() const { return fThetaError; }

    void SetPhiError(double error) { fPhiError=error; }
    double GetPhiError() const { return fPhiError; }

    void SetThetaPhiCorrelation(double corr) { fThetaPhiCorrelation=corr; }
    double GetThetaPhiCorrelation() const { return fThetaPhiCorrelation; }

    // Reconstruction flags

    bool GetT5Trigger() const { return fT5Trigger; }
    void SetT5Trigger(const bool t5) { fT5Trigger = t5; }

    bool IsLdfReconstructed() const { return fLdfReconstructed; }
    void SetLdfReconstructed(bool flag=true) { fLdfReconstructed = flag; } 

   bool IsBetaFixed() const { return fBetaFixed; }
   void SetBetaFixed(bool flag=true) { fBetaFixed = flag; } 

    bool IsCoreFixedLdf() const { return fCoreFixedLdf; }
    void SetCoreFixedLdf(bool flag) { fCoreFixedLdf = flag; } 

    bool IsGeometryReconstructed() const { return fGeometryReconstructed; }
    void SetGeometryReconstructed(bool flag=true) { fGeometryReconstructed = flag; } 

    bool IsCoreFixedGeo() const { return fCoreFixedGeo; }
    void SetCoreFixedGeo(bool flag) { fCoreFixedGeo = flag; } 

    bool IsCurvatureFixed() const { return fCurvatureFixed; }
    void SetCurvatureFixed(bool flag) { fCurvatureFixed = flag; } 

  private:
    ShowerMRecData();
    ~ShowerMRecData() { }
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fMLDF;

    // LDF parameters
    // XXX Maybe sistematics should be added to some of these.
    double fAlpha;
    double fAlphaError;
    double fBeta;
    double fBetaError;
    double fBetaSystematics;
    double fGamma;
    double fGammaError;
    double fR0;
    double fR0Error;
    double fNMuRef; //< Muon LDF size at the reference distance 
    double fNMuRefError;
    double fNMuRefSystematics;
    double fMLDFChi2;
    double fMLDFNdof;
    double fMLDFLikelihood;
    double fReferenceDistance;

    // Geometry parameters
    utl::Vector fAxis; // axis from MD geometrical reconstruction. Currently deprecated and not filled
    double fThetaError;
    double fPhiError;
    double fThetaPhiCorrelation;
    
    // Some geometry parameters from SD reco. It is useful to have access to them here
    utl::Vector fReferenceAxis; // axis from SD reconstruction
    utl::Point fReferenceCore; // core position from SD reconstruction

    utl::TimeStamp fCoreTime;
    utl::TimeInterval fCoreTimeError;

    double fCurvature;
    double fCurvatureError;

    // Core position
    utl::Point fCore; // core position from MD reconstruction. Only filled if a geometrical reconstruction was done by the MD (i.e., if fGeometryReconstructed is true).
    utl::Vector fCoreError;
    double fCorrelationXY;

    utl::Point fBarycenter;

    double fTimeResidualMean;
    double fTimeResidualSpread;
    double fAngleChi2;
    unsigned int fAngleNdof;
    double fMdSdAngle;  

    // Reconstruction status flags
    bool fT5Trigger;
    bool fLdfReconstructed;  // Indicates if the ldf reconstruction was performed
    bool fBetaFixed;   // true is beta is fixed 
    bool fCoreFixedLdf;  // true if the core is fixed in the ldf fit
    bool fGeometryReconstructed;  // Indicates if the geometrical reconstruction was performed
    bool fCoreFixedGeo; // true if the core is fixed in the geometrical reconstruction
    bool fCurvatureFixed; // true if radius of curvature is free in the geometrical reconstruction 

    friend class evt::ShowerRecData;
    friend class utl::LameShadowPtr<ShowerMRecData>;

  };

}

#endif // _evt_ShowerMRecData_h_