#ifndef _evt_ShowerUnivRecData_h_
#define _evt_ShowerUnivRecData_h_

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

namespace evt {

  class ShowerRecData;

  /**
     \class ShowerUnivRecData ShowerUnivRecData.h "evt/ShowerUnivRecData.h"

     \brief Interface class to access to the SD Reconstruction of a Shower (universality)

     \version $Id$
     \ingroup shower
  */

  class ShowerUnivRecData {

  public:
    const utl::Point& GetCorePosition() const { return fCore; }
    const utl::Vector& GetCoreError() const { return fCoreError; }

    /** time when shower front passes through the core point */
    const utl::TimeStamp& GetCoreTime() const { return fCoreTime; }
    const utl::TimeInterval& GetCoreTimeError() const { return fCoreTimeError; }

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

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

    double GetEnergy() const { return fEnergy; }
    double GetEnergyError() const { return fEnergyError; }
    double GetNmu() const { return fNmu; }
    double GetNmuError() const { return fNmuError; }
    double GetXmax() const { return fXmax; }
    double GetXmaxError() const { return fXmaxError; }
    double GetXmaxMu() const { return fXmaxMu; }
    double GetXmaxMuError() const { return fXmaxMuError; }
    double GetTimeModelOffset() const { return fTimeModelOffset; }
    double GetTimeModelOffsetError() const { return fTimeModelOffsetError; }

    bool GetGoodRec() const { return fGoodRec; }

    int GetNumberOfShapeCandidates() const { return fNCandShape; }
    int GetNumberOfStartTimeCandidates() const { return fNCandStartTime; }
    int GetNumberOfLDFCandidates() const { return fNCandLDF; }

    void SetThetaError(const double err) { fThetaError = err; }
    void SetPhiError(const double err) { fPhiError = err; }

    void SetCorePosition(const utl::Point& core) { fCore = core; }
    void SetAxis(const utl::Vector& axis) { fAxis = axis; }
    void SetCoreError(const utl::Vector& coreerr) { fCoreError = coreerr; }
    void SetCoreTime(const utl::TimeStamp& coreTime, const utl::TimeInterval& coreTimeErr)
    { fCoreTime = coreTime; fCoreTimeError = coreTimeErr; }

    void SetEnergy(const double energy, const double error)
    { fEnergy = energy; fEnergyError = error; }
    void SetNmu(const double Nmu, const double error)
    { fNmu = Nmu; fNmuError = error; }
    void SetXmax(const double Xmax, const double error)
    { fXmax = Xmax; fXmaxError = error; }
    void SetXmaxMu(const double XmaxMu, const double error)
    { fXmaxMu = XmaxMu; fXmaxMuError = error; }
    void SetTimeModelOffset(const double mmu, const double mmuunc)
    { fTimeModelOffset = mmu; fTimeModelOffsetError = mmuunc; }
    void SetGoodRec(const bool isgood) { fGoodRec = isgood; }

    void SetNumberOfShapeCandidates(const int ncand) { fNCandShape = ncand; }
    void SetNumberOfStartTimeCandidates(const int ncand) { fNCandStartTime = ncand; }
    void SetNumberOfLDFCandidates(const int ncand) { fNCandLDF = ncand; }

  private:
    ShowerUnivRecData();
    ~ShowerUnivRecData() { }

    utl::Point fCore;
    utl::Vector fCoreError;
    utl::TimeStamp fCoreTime;
    utl::TimeInterval fCoreTimeError;
    utl::Vector fAxis;

    bool fGoodRec;

    double fThetaError;
    double fPhiError;

    double fEnergy;
    double fEnergyError;
    double fNmu;
    double fNmuError;
    double fXmax;
    double fXmaxError;
    double fXmaxMu;
    double fXmaxMuError;
    double fTimeModelOffset;
    double fTimeModelOffsetError;

    int fNCandShape;
    int fNCandStartTime;
    int fNCandLDF;

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

  };

} // evt


#endif // _evt_ShowerUnivRecData_h_

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: