#ifndef _evt_ShowerFRecData_h_
#define _evt_ShowerFRecData_h_

#include <vector>
#include <map>

#include <utl/ShadowPtr.h>
#include <utl/LameShadowPtr_fwd.h>
#include <utl/Vector.h>
#include <utl/Point.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/TabulatedFunction.h>
#include <utl/TabulatedFunctionErrors.h>
#include <evt/VGaisserHillasParameter.h>
#include <evt/MultipleGaisserHillasParameters.h>


namespace fevt {
  class EyeRecData;
}


namespace evt {

  class ShowerRecData;

  /**
     \class ShowerFRecData
     \brief Interface class to access to Fluorescence reconstruction of a Shower

     \date 30 Jan 2003
     \version $Id$
     \ingroup shower
  */

  class ShowerFRecData {

  public:

    /// profile reconstruction uncertainty types
    enum EUncertaintyType {
      eTotal=0,
      eStatistical,
      eAtmospheric
    };

    typedef std::map<EUncertaintyType, double> UncertaintyMap;
    typedef UncertaintyMap::const_iterator UncertaintyMapConstIterator;

  public:
    bool HasLongitudinalProfile() const { return fLongitudinalProfile; }
    /// retrieve longitudinal profile information (size vs depth)
    utl::TabulatedFunctionErrors& GetLongitudinalProfile()
    { return *fLongitudinalProfile; }
    const utl::TabulatedFunctionErrors& GetLongitudinalProfile() const
    { return *fLongitudinalProfile; }
    void MakeLongitudinalProfile();

    bool HasFluorescencePhotons() const { return fFluorescencePhotons; }
    /// retrieve number of fluorescence photons versus depth
    utl::TabulatedFunctionErrors& GetFluorescencePhotons()
    { return *fFluorescencePhotons; }
    const utl::TabulatedFunctionErrors& GetFluorescencePhotons() const
    { return *fFluorescencePhotons; }
    void MakeFluorescencePhotons();

    bool HasCherenkovPhotons() const { return fCherenkovPhotons; }
    /// retrieve number of Cerenkov photons versus depth
    utl::TabulatedFunction& GetCherenkovPhotons()
    { return *fCherenkovPhotons; }
    const utl::TabulatedFunction& GetCherenkovPhotons() const
    { return *fCherenkovPhotons; }
    void MakeCherenkovPhotons();

    bool HasGHParameters() const { return fGHParameters; }
    /// retrieve  Gasser-Hillas parameters
    evt::VGaisserHillasParameter& GetGHParameters()
    { return *fGHParameters; }
    const evt::VGaisserHillasParameter& GetGHParameters() const
    { return *fGHParameters; }
    void MakeGHParameters(const VGaisserHillasParameter& gh);

    bool HasMultipleGHParameters() const { return fMultipleGHParameters.GetVirtualParameters().size(); }
    evt::MultipleGaisserHillasParameters&
    GetMultipleGHParameters() { return fMultipleGHParameters; }
    const evt::MultipleGaisserHillasParameters&
    GetMultipleGHParameters() const { return fMultipleGHParameters; }
    void MakeMultipleGHParameters(const std::vector<double>& dgh);

    bool HasEnergyDeposit() const { return fEnergyDeposit; }
    /// retrieve  dE/dX
    utl::TabulatedFunctionErrors& GetEnergyDeposit()
    { return *fEnergyDeposit; }
    const utl::TabulatedFunctionErrors& GetEnergyDeposit() const
    { return *fEnergyDeposit; }
    void MakeEnergyDeposit();

    void SetEmEnergy(const double energy, const double energyError,
		     const EUncertaintyType type = eTotal )
    { fEmEnergy = energy; fEmEnergyError[type] = energyError; }
    void SetEmEnergyError(const double energyError, const EUncertaintyType type )
    { fEmEnergyError[type] = energyError; }

    void SetTotalEnergy(const double energy, const double energyError,
			const EUncertaintyType type = eTotal )
    { fTotalEnergy = energy; fTotalEnergyError[type] = energyError; }
    void SetTotalEnergyError(const double energyError, const EUncertaintyType type)
    { fTotalEnergyError[type] = energyError; }

    void SetXmaxError(const double xmaxError, const EUncertaintyType type)
    { fXmaxError[type] = xmaxError; }

    void SetEnergyCutoff(const double energy) { fEnergyCutoff = energy; }

    /// add a station id to the list of used hybrid stations
    void AddStationId(const unsigned short int id) { fStationIds.push_back(id); }

    /// retrieve  electromagnetic energy and its uncertainty
    double GetEmEnergy() const { return fEmEnergy; }
    double GetEmEnergyError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetEmEnergyErrorsBegin() const
    { return fEmEnergyError.begin();}
    UncertaintyMapConstIterator GetEmEnergyErrorsEnd() const
    { return fEmEnergyError.end();}
    bool  HasEmEnergyError(const EUncertaintyType type = eTotal) const;

    /// retrieve  total energy and its uncertainty
    double GetTotalEnergy() const { return fTotalEnergy; }
    double GetTotalEnergyError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetTotalEnergyErrorsBegin() const
    { return fTotalEnergyError.begin();}
    UncertaintyMapConstIterator GetTotalEnergyErrorsEnd() const
    { return fTotalEnergyError.end();}
    bool  HasTotalEnergyError(const EUncertaintyType type = eTotal) const;

    /// retrieve Xmax uncertainties
    double GetXmaxError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetXmaxErrorsBegin() const
    { return fXmaxError.begin();}
    UncertaintyMapConstIterator GetXmaxErrorsEnd() const
    { return fXmaxError.end();}
    bool HasXmaxError(const EUncertaintyType type = eTotal) const;

    /// retrieve energy cutoff for which the profile of charged particles was calculated.
    double GetEnergyCutoff() const { return fEnergyCutoff; }

    /// retrieve vector of station IDs used in hybrid fit
    std::vector<unsigned short int>& GetStationIds() { return fStationIds; }
    const std::vector<unsigned short int>& GetStationIds() const { return fStationIds; }

    void SetSDTimeResidual (double time) {fSDTimeResidual=time;}
    double GetSDTimeResidual() const {return fSDTimeResidual;}

    /// Shower Axis as reconstructed by the FD or FD eye
    const utl::Vector& GetAxis() const { return fAxis; }

    /// Error on shower axis
    const utl::Vector& GetAxisError() const { return fAxisError; }

    /// Shower core as reconstructed by the FD or FD eye
    const utl::Point& GetCorePosition() const { return fCore; }

    /// Shower core as reconstructed by the FD or FD eye
    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; }

    /// core xy correlation (MU: in which coordinate system???)
    double GetCorrelationXY() const {return fCorrelationXY;}

    /// axis theta/phi correlation (MU: in which coordinate system???)
    double GetCorrelationThetaPhi() const {return fCorrelationThetaPhi;}

    /// point on shower corresponding to a certain light arrival time at telescope
    utl::Point CalculatePointOnShower(const utl::TimeStamp& timeAtTelescope,
                                      const utl::Point& telescopePosition) const;

    void SetCoreTime(const utl::TimeStamp& coreTime,
                     const utl::TimeInterval& coreTimeErr)
    { fCoreTime = coreTime; fCoreTimeError = coreTimeErr; }
    void SetCoreTime(const utl::TimeStamp& eyeTriggerTime,
                     const double rp, const double chi0, const double t0);
    void SetAxis(const utl::Vector& axis) { fAxis = axis; }
    void SetAxisError(const utl::Vector& axis_er) { fAxisError = axis_er; }
    void SetCorePosition(const utl::Point& core) { fCore = core; }
    void SetCoreError(const utl::Vector& core_er) { fCoreError = core_er; }
    void SetCorrelationXY (double corr) {fCorrelationXY=corr;}
    void SetCorrelationThetaPhi (double corr) {fCorrelationThetaPhi=corr;}

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

    utl::ShadowPtr<utl::TabulatedFunctionErrors> fEnergyDeposit;
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fLongitudinalProfile;
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fFluorescencePhotons;
    utl::ShadowPtr<utl::TabulatedFunction> fCherenkovPhotons;
    utl::ShadowPtr<evt::VGaisserHillasParameter> fGHParameters;

    double fEmEnergy;
    double fTotalEnergy;
    UncertaintyMap fEmEnergyError;
    UncertaintyMap fTotalEnergyError;
    UncertaintyMap fXmaxError;

    double fEnergyCutoff;

    utl::Vector fAxis;
    utl::Vector fAxisError;
    utl::Point fCore;
    utl::Vector fCoreError;
    double fCorrelationXY;

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

    double fCorrelationThetaPhi;
    double fSDTimeResidual;

    std::vector<unsigned short int> fStationIds;

    evt::MultipleGaisserHillasParameters fMultipleGHParameters;

    friend class evt::ShowerRecData;
    friend class fevt::EyeRecData;
    friend class utl::LameShadowPtr<ShowerFRecData>;

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: