ShowerSRecData.h

Go to the documentation of this file.

#ifndef _evt_ShowerSRecData_h_
#define _evt_ShowerSRecData_h_

#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/Histogram.h>
#include <utl/LameShadowPtr_fwd.h>
#include <utl/ShadowPtr.h>
#include <evt/RiseTime1000.h>
#include <evt/ShowerSRecDataQuantities.h>
#include <sevt/PlaneFrontRecData.h>
#include <sevt/SdFootprintData.h>
#include <utl/ParameterStorage.h>
#include <sevt/SEventConstants.h>

#include <string>
#include <vector>


namespace evt {

  class ShowerRecData;
  class ShowerScintillatorRecData;


  class ShowerSRecData {

  public:
    enum ShowerSizeType {
      eUndefined = -1,
      eS1000 = 0,
      eS450 = 1,
      eN19 = 2,
      eS300 = 3
    };

    ShowerScintillatorRecData& GetScintillatorRecShower() { return *fShowerScintillatorRecData; }
    const ShowerScintillatorRecData& GetScintillatorRecShower() const { return *fShowerScintillatorRecData; }
    void MakeScintillatorRecShower();
    bool HasScintillatorRecShower() const { return bool(fShowerScintillatorRecData); }

    const utl::TabulatedFunctionErrors& GetLDF() const { return *fLDF; }
    utl::TabulatedFunctionErrors& GetLDF() { return *fLDF; }
    bool HasLDF() const { return bool(fLDF); }
    void MakeLDF();

    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 GetNKGFermiMu() const { return fNKGFermiMu; }
    double GetNKGFermiTau() const { return fNKGFermiTau; }
    double GetCurvature() const { return fCurvature; }
    double GetCurvatureError() const { return fCurvatureError; }
    double GetCurvatureTimeOffset() const { return fCurvatureTimeOffset; }
    double GetCurvatureTimeOffsetError() const { return fCurvatureTimeOffsetError; }

    int GetNumberOfActiveStations() const { return fNumberOfActiveStations; }

    bool HasShowerSizeType(const ShowerSizeType type) const { return type == fShowerSizeType; }
    ShowerSizeType GetShowerSizeType() const { return fShowerSizeType; }
    const char* GetShowerSizeLabel() const;
    double GetShowerSize() const { return fShowerSize; }
    double GetShowerSizeError() const { return fShowerSizeError; }
    double GetShowerSizeSystematics() const { return fShowerSizeSystematics; }
    double GetCicRefAngle() const { return fCicRefAngle; }
    double GetS38() const { return fS38; }

    double GetLDFOptimumDistance() const { return fLDFOptimumDistance; }
    double GetSizeAtmosphericCorr() const { return fSizeAtmosphericCorr; }
    double GetSizeGeomagneticCorr() const { return fSizeGeomagneticCorr; }
    double GetSizeAtmosphericCorrError() const { return fSizeAtmosphericCorrError; }
    double GetSizeGeomagneticCorrError() const { return fSizeGeomagneticCorrError; }

    void SetCurvature(const double curvature, const double error) { fCurvature = curvature; fCurvatureError = error; }
    void SetCurvatureTimeOffset(const double ct0, const double ct0Error)
    { fCurvatureTimeOffset = ct0; fCurvatureTimeOffsetError = ct0Error; }

    void SetBeta(const double beta, const double error)
    { fBeta = beta; fBetaError = error; }
    void SetBetaSystematics(const double betasys) { fBetaSystematics = betasys; }
    void SetGamma(const double gamma, const double error)
    { fGamma = gamma; fGammaError = error; }
    void SetNKGFermiParameters(const double mu, const double tau)
    { fNKGFermiMu = mu; fNKGFermiTau = tau; }
    void SetNumberOfActiveStations(const int nstations)
    { fNumberOfActiveStations = nstations; }
    void SetShowerSizeType(const ShowerSizeType type) { fShowerSizeType = type; }
    void SetShowerSize(const double value, const double error) { fShowerSize = value; fShowerSizeError = error; }
    void SetCicRefAngle(const double angle) { fCicRefAngle = angle; }
    void SetS38(const double s38) { fS38 = s38; }
    void SetShowerSizeSystematics(const double sysError) { fShowerSizeSystematics = sysError; }
    void SetLDFOptimumDistance(const double rOpt) { fLDFOptimumDistance = rOpt; }
    void SetSizeAtmosphericCorr(const double what, const double whatEr)
    { fSizeAtmosphericCorr = what; fSizeAtmosphericCorrError = whatEr; }
    void SetSizeGeomagneticCorr(const double what, const double whatEr)
    { fSizeGeomagneticCorr = what; fSizeGeomagneticCorrError = whatEr; }

    const utl::Point& GetBarycenter() const { return fBarycenter; }
    const utl::TimeStamp& GetBarytime() const { return fBarytime; }
    const utl::CoordinateSystemPtr& GetBarycenterCoordinateSystem() const;

    const utl::Point& GetCorePosition() const { return fCore; }
    const utl::Vector& GetCoreError() const { return fCoreError; }
    double GetCorrelationXY() const { return fCorrelationXY; }
    const utl::TimeStamp& GetCoreTime() const { return fCoreTime; }
    const utl::TimeInterval& GetCoreTimeError() const { return fCoreTimeError; }
    const utl::CoordinateSystemPtr& GetCoreCoordinateSystem() const;
    const utl::CoordinateSystemPtr& GetShowerCoordinateSystem() const;

    const utl::Vector& GetAxis() const { return fAxis; }

    double GetThetaError() const { return fThetaError; }
    double GetPhiError() const { return fPhiError; }
    double GetCorrelationThetaPhi() const { return fCorrelationThetaPhi; }

    double GetEnergy() const { return fEnergy; }
    double GetEnergyError() const { return fEnergyError; }
    double GetEnergyLDFSystematics() const { return fEnergyLDFSystematics;}

    utl::Point GetShowerCenter() const;

    utl::Histogram<double>& GetMPDHistogram() { return *fMPDHistogram; }
    const utl::Histogram<double>& GetMPDHistogram() const { return *fMPDHistogram; }
    void MakeMPDHistogram(const int nBins, const double min, const double max);
    bool HasMPDHistogram() const { return bool(fMPDHistogram); }

    double GetAngleChi2() const { return fAngleChi2; }
    double GetAngleNdof() const { return fAngleNdof; }
    double GetTimeResidualMean() const { return fTimeResidualMean; }
    double GetTimeResidualSpread() const { return fTimeResidualSpread; }

    double GetLDFChi2() const { return fLDFChi2; }
    double GetLDFNdof() const { return fLDFNdof; }
    double GetLDFLikelihood() const { return fLDFLikelihood; }

    int GetT4Trigger() const { return fT4Trigger; }
    bool IsT4() const { return fT4Trigger; }

    int GetT5Trigger() const { return fT5Trigger; }
    bool IsT5() const { return fT5Trigger; }

    int GetT5HottestStation() const { return fT5HottestStation; }
    int GetT5ClosestStation() const { return fT5ClosestStation; }
    bool IsT5ClosestStationUUB() const { return fT5ClosestStationIsUUB; }
    const std::vector<int>& GetT5PriorActiveNeighbors() const { return fT5PriorActiveNeighbors; }
    const std::vector<int>& GetT5PriorActiveUUBNeighbors() const { return fT5PriorActiveUUBNeighbors; }
    const std::vector<int>& GetT5PosteriorActiveNeighbors() const { return fT5PosteriorActiveNeighbors; }
    const std::vector<int>& GetT5PosteriorActiveUUBNeighbors() const { return fT5PosteriorActiveUUBNeighbors; }
    unsigned int GetT5PosteriorCoreTriangle() const { return fT5PosteriorCoreTriangle; }

    void SetIsTOTdMoPSSilent(const bool silent) { fIsTOTdMoPSSilent = silent; }
    bool IsTOTdMoPSSilent() const { return fIsTOTdMoPSSilent; }

    const std::vector<int>& GetReconstructionSeed() const { return fReconstructionSeed; }

    const utl::Vector& GetSeedAxis() const { return fSeedAxis; }
    const utl::Point& GetSeedBarycenter() const { return fSeedBarycenter; }

    void SetThetaError(const double err) { fThetaError = err; }
    void SetPhiError(const double err) { fPhiError = err; }
    void SetAngleErrors(const utl::Vector::Triple& u_v_w,
                        const utl::Vector::Triple& sigma_u2_uv_v2);
    void SetCorrelationThetaPhi(const double corr) { fCorrelationThetaPhi = corr; }
    void SetAngleChi2(const double chi2, const double ndof)
    { fAngleChi2 = chi2; fAngleNdof = ndof; }
    void SetTimeResidualMean(const double mean) { fTimeResidualMean = mean; }
    void SetTimeResidualSpread(const double spread) { fTimeResidualSpread = spread; }

    void SetBarycenter(const utl::Point& bary) { fBarycenter = bary; fBarycenterCoordinateSystem.reset(); }
    void SetBarytime(const utl::TimeStamp& t) { fBarytime = t; }

    void SetCorePosition(const utl::Point& core) { fCore = core; fCoreCoordinateSystem.reset(); fShowerCoordinateSystem.reset(); }
    void SetAxis(const utl::Vector& axis) { fAxis = axis; fShowerCoordinateSystem.reset(); }
    void SetCoreError(const utl::Vector& coreerr) { fCoreError = coreerr; }
    void SetCorrelationXY(const double corr) { fCorrelationXY = corr; }
    void SetCoreTime(const utl::TimeStamp& coreTime, const utl::TimeInterval& coreTimeErr)
    { fCoreTime = coreTime; fCoreTimeError = coreTimeErr; }
    void SetLDFChi2(const double chi2, const double ndof)
    { fLDFChi2 = chi2; fLDFNdof = ndof; }
    void SetLDFLikelihood(const double likelihood) { fLDFLikelihood = likelihood; }

    void SetEnergy(const double energy, const double error)
    { fEnergy = energy; fEnergyError = error; }
    void SetEnergyLDFSystematics(const double sys)
    { fEnergyLDFSystematics = sys; }

    void SetT4Trigger(const int t4) { fT4Trigger = t4; }

    void SetT5Trigger(const int t5) { fT5Trigger = t5; }

    void SetT5HottestStation(const int id) { fT5HottestStation = id; }
    void SetT5ClosestStation(const int id) { fT5ClosestStation = id; }
    void SetT5ClosestStationIsUUB(const bool flag) { fT5ClosestStationIsUUB = flag; }
    void SetT5PriorActiveNeighbors(const std::vector<int>& neigh) { fT5PriorActiveNeighbors = neigh; }
    void SetT5PriorActiveUUBNeighbors(const std::vector<int>& neigh) { fT5PriorActiveUUBNeighbors = neigh; }
    void SetT5PosteriorActiveNeighbors(const std::vector<int>& neigh) { fT5PosteriorActiveNeighbors = neigh; }
    void SetT5PosteriorActiveUUBNeighbors(const std::vector<int>& neigh) { fT5PosteriorActiveUUBNeighbors = neigh; }
    void SetT5PosteriorCoreTriangle(const unsigned int type) { fT5PosteriorCoreTriangle = type; }

    void SetReconstructionSeed(const std::vector<int>& stations)
    { fReconstructionSeed = stations; }

    double GetLDFRecStage() const { return fLDFRecStage; }
    void SetLDFRecStage(const double stage) { fLDFRecStage = stage; }

    void SetSeedAxis(const utl::Vector& axis) { fSeedAxis = axis; }
    void SetSeedBarycenter(const utl::Point& b) { fSeedBarycenter = b; }

    int GetBadPeriodId() const { return fBadPeriodId; }
    void SetBadPeriodId(const int id) { fBadPeriodId = id; }

    bool HasRiseTime1000() const { return bool(fRiseTime1000); }
    void MakeRiseTime1000() { fRiseTime1000 = new evt::RiseTime1000; }
    evt::RiseTime1000& GetRiseTime1000() { return *fRiseTime1000; }
    const evt::RiseTime1000& GetRiseTime1000() const { return *fRiseTime1000; }

    bool HasPlaneFrontRecData() const { return bool(fPlaneFrontRecData); }
    void MakePlaneFrontRecData() { fPlaneFrontRecData = new sevt::PlaneFrontRecData; }
    sevt::PlaneFrontRecData& GetPlaneFrontRecData() { return *fPlaneFrontRecData; }
    const sevt::PlaneFrontRecData& GetPlaneFrontRecData() const { return *fPlaneFrontRecData; }

    bool HasFootprintData() const { return bool(fFootprintData); }
    void MakeFootprintData() { fFootprintData = new sevt::SdFootprintData; }
    sevt::SdFootprintData& GetFootprintData() { return *fFootprintData; }
    const sevt::SdFootprintData& GetFootprintData() const { return *fFootprintData; }

    // MODIFIED PARAMETERSTORAGE
    typedef sevt::ShowerSRecDataQuantities Parameter;
    void SetParameter(const Parameter q, const double param, const bool lock = true)
    { fParameterStorage.SetParameter(q, param, lock, CurrentModule()); }
    void SetParameterCovariance(const Parameter q1, const Parameter q2, const double corr, const bool lock = true)
    { fParameterStorage.SetParameterCovariance(q1, q2, corr, lock, CurrentModule()); }
    bool HasParameter(const Parameter q) const { return fParameterStorage.HasParameter(q); }
    bool HasParameterCovariance(const Parameter q1, const Parameter q2) const
    { return fParameterStorage.HasParameterCovariance(q1, q2); }
    double GetParameter(const Parameter q) const { return fParameterStorage.GetParameter(q, CurrentModule()); }
    bool GetParameterLockStatus(const Parameter q) const
    { return fParameterStorage.GetParameterLockStatus(q, CurrentModule()); }
    double GetParameterError(const Parameter q) const
    { return std::sqrt(fParameterStorage.GetParameterCovariance(q, q, CurrentModule())); }
    bool GetParameterErrorLockStatus(const Parameter q) const
    { return fParameterStorage.GetParameterCovarianceLockStatus(q, q, CurrentModule()); }
    bool HasParameterError(const Parameter q) const
    { return fParameterStorage.HasParameterCovariance(q, q); }
    double GetParameterCovariance(const Parameter q1, const Parameter q2) const
    { return fParameterStorage.GetParameterCovariance(q1, q2, CurrentModule()); }
    bool GetParameterCovarianceLockStatus(const Parameter q1, const Parameter q2) const
    { return fParameterStorage.GetParameterCovarianceLockStatus(q1, q2, CurrentModule()); }
    void DeleteParameter(const Parameter q) { fParameterStorage.DeleteParameter(q, CurrentModule()); }
    void DeleteParameterCovariance(const Parameter q1, const Parameter q2)
    { fParameterStorage.DeleteParameterCovariance(q1, q2, CurrentModule()); }
    std::vector<Parameter> GetEnumVector() const { return fParameterStorage.GetEnumVector(); }
    std::vector<std::pair<Parameter, Parameter>> GetCovarianceEnumVector() const
    { return fParameterStorage.GetCovarianceEnumVector(); }

  private:
    ShowerSRecData() = default;
    ~ShowerSRecData() = default;

    static const std::string& CurrentModule() { return fwk::RunController::GetInstance().GetCurrentModule(); }

    utl::ShadowPtr<utl::TabulatedFunctionErrors> fLDF;

    utl::ParameterStorage<Parameter> fParameterStorage{"Shower:ShowerSRecData"};

    utl::Point fBarycenter;
    utl::TimeStamp fBarytime;
    mutable utl::CoordinateSystemPtr fBarycenterCoordinateSystem;

    utl::Point fCore;
    utl::Vector fCoreError;
    double fCorrelationXY = 0;
    utl::TimeStamp fCoreTime;
    utl::TimeInterval fCoreTimeError;
    mutable utl::CoordinateSystemPtr fCoreCoordinateSystem;
    mutable utl::CoordinateSystemPtr fShowerCoordinateSystem;
    utl::Vector fAxis;

    double fBeta = 0;
    double fBetaError = 0;
    double fBetaSystematics = 0;
    double fGamma = 0;
    double fGammaError = 0;
    double fNKGFermiMu = 0;
    double fNKGFermiTau = 0;
    double fCurvature = 0;
    double fCurvatureError = 0;
    double fCurvatureTimeOffset = 0;
    double fCurvatureTimeOffsetError = 0;
    ShowerSizeType fShowerSizeType = eUndefined;
    double fShowerSize = 0;
    double fShowerSizeError = 0;
    double fShowerSizeSystematics = 0;
    double fCicRefAngle = 0;
    double fS38 = 0;
    double fSizeGeomagneticCorr = 0;
    double fSizeGeomagneticCorrError = 0;
    double fSizeAtmosphericCorr = 0;
    double fSizeAtmosphericCorrError = 0;
    double fLDFOptimumDistance = 0;
    double fLDFChi2 = 0;
    double fLDFNdof = 0;
    double fLDFLikelihood = 0;

    double fThetaError = 0;
    double fPhiError = 0;
    double fCorrelationThetaPhi = 0;
    double fAngleChi2 = 0;
    double fAngleNdof = 0;
    double fTimeResidualMean = 0;
    double fTimeResidualSpread = 0;
    double fEnergy = 0;
    double fEnergyError = 0;
    double fEnergyLDFSystematics = 0;

    int fNumberOfActiveStations = 0;

    int fT4Trigger = 0;
    int fT5Trigger = 0;
    int fT5HottestStation = 0;
    int fT5ClosestStation = 0;
    std::vector<int> fT5PriorActiveNeighbors;
    std::vector<int> fT5PriorActiveUUBNeighbors;
    std::vector<int> fT5PosteriorActiveNeighbors;
    std::vector<int> fT5PosteriorActiveUUBNeighbors;
    unsigned int fT5PosteriorCoreTriangle = sevt::SEventConstants::eNone;
    bool fT5ClosestStationIsUUB = false;

    bool fIsTOTdMoPSSilent = true;

    std::vector<int> fReconstructionSeed;

    double fLDFRecStage = 0;

    // estimated properties by selection
    utl::Vector fSeedAxis;
    utl::Point fSeedBarycenter;

    utl::ShadowPtr<utl::Histogram<double>> fMPDHistogram;

    int fBadPeriodId = 0;

    utl::ShadowPtr<evt::RiseTime1000> fRiseTime1000;

    utl::ShadowPtr<sevt::PlaneFrontRecData> fPlaneFrontRecData;
    utl::ShadowPtr<sevt::SdFootprintData> fFootprintData;

    utl::LameShadowPtr<evt::ShowerScintillatorRecData> fShowerScintillatorRecData;

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

  public:
    // see GAP 2005-023
    enum T4Flags {
      eT4_None    = 0,
      eT4_FD      = 1 << 0,  //< any of TOT or Threshold configurations that were triggered by FD
      eT4_3TOT    = 1 << 1,  //< 3 not-aligned tanks with TOT trigger (3TOT)
      eT4_4C1     = 1 << 2,  //< 4 tanks with T2 in 4C1 configuration (4C1)
      eT4_3TOTd   = 1 << 3,  //< 3 not-aligned tanks with TOTd trigger (3TOTd)
      eT4_3TOTMix = 1 << 4,   //< 3 not-aligned tanks with TOTd, MoPs or TOT trigger (3TOTMix)
      eT4_3MoPS   = 1 << 5,   //< 3 not-aligned tanks with MoPS trigger (3MoPS)
    };

    enum T5Flags {
      eT5_None      = 0,
      eT5_Prior     = 1 << 0,  //< a minimal number of active stations are surounding the hotest one
      eT5_Posterior = 1 << 1,  //< the core is enclosed by 3 active stations (from the hottest hexagon) forming a equilateral or isosceles triangle
      eT5_Has       = 1 << 2   //< station closed to core is active and surrounded by 6 active stations
    };

    static const double kBary;
    static const double kPlaneFitLinear;
    static const double kPlaneFitLinear2;
    static const double kPlaneFit3d;
    static const double kLDFEstimate;
    static const double kLDFEstimateAndCurvature;
    static const double kLDF;
    static const double kLDFAndCurvature;
    static const double kLDFSilents;
    static const double kLDFSilentsAndCurvature;
    static const double kLDFGlobalFit;
    static const double kLDFBeta;
    static const double kLDFGamma;
    static const double kLDFLowerLimit;

  };

}


#endif