EyeRecData.h

Go to the documentation of this file.

#ifndef _fevt_EyeRecData_h_
#define _fevt_EyeRecData_h_

#include <fevt/Eye.h>
#include <fevt/CoordinateData.h>

#include <utl/TimeStamp.h>
#include <utl/AxialVector.h>
#include <utl/MultiTabulatedFunctionErrors.h>
#include <utl/ShadowPtr.h>
#include <utl/LameShadowPtr.h>

#include <boost/iterator/indirect_iterator.hpp>

#include <vector>


namespace evt {
  class ShowerFRecData;
}

namespace fevt {

  class Pixel;

  class PCGFData {

  public:
    enum EPCGFStatus {
      eUnknown,
      ePreFit,
      eScan,
      eFit,
      eFinal
    };
    
    PCGFData() : fChi0(0), fRp(0), fT0(0), fStatus(eUnknown) {}
  PCGFData(double a, double b, double c, EPCGFStatus d, const std::map<std::string,double>& e, const std::map<std::string,double>& f) : fChi0(a), fRp(b), fT0(c), fStatus(d), fChi2(e), fNDof(f) {}
    double GetChi0() const { return fChi0; }
    double GetT0() const { return fT0; }
    double GetRp() const { return fRp; }
    EPCGFStatus GetStatus() const { return fStatus; }
    const std::map<std::string,double>& GetChi2() const { return fChi2; }
    const std::map<std::string,double>& GetNDof() const { return fNDof; }
  private:
    double fChi0;
    double fRp;
    double fT0;
    EPCGFStatus fStatus;
    std::map<std::string, double> fChi2;
    std::map<std::string, double> fNDof;
  };
    
  class EyeRecData {

  private:
    typedef std::vector<fevt::Pixel*> InternalPixelContainer;
    typedef InternalPixelContainer::iterator InternalPixelIterator;
    typedef InternalPixelContainer::const_iterator ConstInternalPixelIterator;

  public:
    unsigned int GetEyeId() const { return fEyeId; }

    const utl::AxialVector& GetSDP() const { return fSDP; }
    double GetZeta() const { return fZeta; }
    double GetSDPThetaError() const { return fSDPThetaError; }
    double GetSDPPhiError() const { return fSDPPhiError; }
    double GetSDPCorrThetaPhi() const { return fSDPThetaPhiCorrelation; }
    double GetSDPFitChiSquare() const { return fSDPFitChiSquare; }
    unsigned int GetSDPFitNDof() const { return fSDPFitNDof; }

    double GetTZero() const { return fTZero; }
    double GetTZeroError() const { return fTZeroError; }
    double GetChiZero() const { return fChiZero; }
    double GetChiZeroError() const { return fChiZeroError; }
    double GetRp() const { return fRp; }
    double GetChi0TZeroCorrelation() const { return fChi0TZeroCorrelation; }
    double GetRpChi0Correlation() const { return fRpChi0Correlation; }
    double GetRpTZeroCorrelation() const { return fRpTZeroCorrelation; }
    double GetRpError() const { return fRpError; }
    double GetTimeFitChiSquare() const { return fTimeFitChiSquare; }
    unsigned int GetTimeFitNDof() const { return fTimeFitNDof; }

    double GetNorthEastCorrelation() const { return fNorthEastCorrelation; }
    double GetNorthThetaCorrelation() const { return fNorthThetaCorrelation; }
    double GetNorthPhiCorrelation() const { return fNorthPhiCorrelation; }
    double GetNorthTCoreCorrelation() const { return fNorthTCoreCorrelation; }
    double GetEastThetaCorrelation() const { return fEastThetaCorrelation; }
    double GetEastPhiCorrelation() const { return fEastPhiCorrelation; }
    double GetEastTCoreCorrelation() const { return fEastTCoreCorrelation; }
    double GetThetaPhiCorrelation() const { return fThetaPhiCorrelation; }
    double GetThetaTCoreCorrelation() const { return fThetaTCoreCorrelation; }
    double GetPhiTCoreCorrelation() const { return fPhiTCoreCorrelation; }
    double GetAxisFitChiSquare() const { return fAxisFitChiSquare; }
    unsigned int GetAxisFitNDof() const { return fAxisFitNDof; }

    typedef boost::indirect_iterator<InternalPixelIterator,
                                     fevt::Pixel&> PixelIterator;

    typedef boost::indirect_iterator<ConstInternalPixelIterator,
                                     const Pixel&> ConstPixelIterator;

    PixelIterator PulsedPixelsBegin()
    { return PixelIterator(fPulsedPixels.begin()); }
    PixelIterator PulsedPixelsEnd()
    { return PixelIterator(fPulsedPixels.end()); }
    ConstPixelIterator PulsedPixelsBegin() const
    { return ConstPixelIterator(fPulsedPixels.begin()); }
    ConstPixelIterator PulsedPixelsEnd() const
    { return ConstPixelIterator(fPulsedPixels.end()); }

    void AddPulsedPixel(fevt::Pixel& pixel)
    { fPulsedPixels.push_back(&pixel); }

    PixelIterator RemovePulsedPixel(PixelIterator it)
    { return PixelIterator(fPulsedPixels.erase(it.base())); }

    unsigned int GetNPulsedPixels() const { return fPulsedPixels.size(); }

    PixelIterator SDPPixelsBegin()
    { return PixelIterator(fSDPPixels.begin()); }
    ConstPixelIterator SDPPixelsBegin() const
    { return ConstPixelIterator(fSDPPixels.begin()); }
    PixelIterator SDPPixelsEnd()
    { return PixelIterator(fSDPPixels.end()); }
    ConstPixelIterator SDPPixelsEnd() const
    { return ConstPixelIterator(fSDPPixels.end()); }

    void AddSDPPixel(fevt::Pixel& pixel) { fSDPPixels.push_back(&pixel); }


    PixelIterator RemoveSDPPixel(PixelIterator it)
    { return PixelIterator(fSDPPixels.erase(it.base())); }

    unsigned int GetNSDPPixels() const { return fSDPPixels.size(); }

    PixelIterator TimeFitPixelsBegin()
    { return PixelIterator(fTimeFitPixels.begin()); }
    ConstPixelIterator TimeFitPixelsBegin() const
    { return ConstPixelIterator(fTimeFitPixels.begin()); }
    PixelIterator TimeFitPixelsEnd()
    { return PixelIterator(fTimeFitPixels.end()); }
    ConstPixelIterator TimeFitPixelsEnd() const
    { return ConstPixelIterator(fTimeFitPixels.end()); }

    void AddTimeFitPixel(fevt::Pixel& pixel) { fTimeFitPixels.push_back(&pixel); }

    PixelIterator RemoveTimeFitPixel(PixelIterator it)
    { return PixelIterator(fTimeFitPixels.erase(it.base())); }

    unsigned int GetNTimeFitPixels() const { return fTimeFitPixels.size(); }

    typedef std::vector<CoordinateData>::iterator CoordinateIterator;
    typedef std::vector<CoordinateData>::const_iterator ConstCoordinateIterator;

    ConstCoordinateIterator CoordinatesBegin() const
    { return fCoordinateData.begin(); }

    ConstCoordinateIterator CoordinatesEnd() const
    { return fCoordinateData.end(); }

    CoordinateIterator CoordinatesBegin()
    { return fCoordinateData.begin(); }

    CoordinateIterator CoordinatesEnd()
    { return fCoordinateData.end(); }

    void AddCoordinate(const fevt::CoordinateData& coor)
    { fCoordinateData.push_back(coor); }

    CoordinateIterator RemoveCoordinate(CoordinateIterator it)
    { return fCoordinateData.erase(it); }

    unsigned int GetNCoordinates() const
    { return fCoordinateData.size(); }

    void ClearCoordinates() { fCoordinateData.clear(); }

    void SetEyeId(const unsigned int id) { fEyeId = id; }

    void SetZeta(const double zeta) { fZeta = zeta; }

    void SetSDP(const utl::AxialVector& vec) { fSDP = vec; }

    void SetSDPThetaError(const double sdpThetaError)
    { fSDPThetaError = sdpThetaError; }

    void SetSDPPhiError(const double sdpPhiError)
    { fSDPPhiError = sdpPhiError; }

    void SetSDPCorrThetaPhi (double sdpCorrThetaPhi)
    { fSDPThetaPhiCorrelation=sdpCorrThetaPhi; }

    void SetSDPFitChiSquare(const double sdpChi2, const unsigned int ndof)
    { fSDPFitChiSquare = sdpChi2; fSDPFitNDof = ndof; }

    void SetTimeFitChiSquare(const double tfitChi2, const unsigned int ndof)
    { fTimeFitChiSquare = tfitChi2; fTimeFitNDof = ndof; }

    void SetTZero(const double tzero, const double error)
    { fTZero = tzero; fTZeroError = error; }
    void SetChiZero(const double chiZero, const double error)
    { fChiZero = chiZero; fChiZeroError = error; }
    void SetRp(const double rp, const double error)
    {  fRp = rp; fRpError = error; }

    void
    SetTimeFitCorrelations(const double rRpT0, const double rRpChi0, const double rChi0T0)
    {
      fRpTZeroCorrelation = rRpT0;
      fRpChi0Correlation = rRpChi0;
      fChi0TZeroCorrelation = rChi0T0;
    }

    void
    SetAxisFitCorrelations(const double northEast,
                           const double northTheta,
                           const double northPhi,
                           const double northTCore,
                           const double eastTheta,
                           const double eastPhi,
                           const double eastTCore,
                           const double thetaPhi,
                           const double thetaTCore,
                           const double phiTCore)
    {
      fNorthEastCorrelation = northEast;
      fNorthThetaCorrelation = northTheta;
      fNorthPhiCorrelation = northPhi;
      fNorthTCoreCorrelation = northTCore;
      fEastThetaCorrelation = eastTheta;
      fEastPhiCorrelation = eastPhi;
      fEastTCoreCorrelation = eastTCore;
      fThetaPhiCorrelation = thetaPhi;
      fThetaTCoreCorrelation = thetaTCore;
      fPhiTCoreCorrelation = phiTCore;
    }

    void SetAxisFitChiSquare(const double globalChi2, const unsigned int ndof)
    { fAxisFitChiSquare = globalChi2; fAxisFitNDof = ndof; }


    utl::TabulatedFunctionErrors& GetLightFlux(const FdConstants::LightSource source = fevt::FdConstants::eTotal)
    { return fLightProfile->GetTabulatedFunctionErrors(source); }
    const utl::TabulatedFunctionErrors& GetLightFlux(const FdConstants::LightSource source = fevt::FdConstants::eTotal) const
    { return fLightProfile->GetTabulatedFunctionErrors(source); }

    void MakeLightFlux(const FdConstants::LightSource source = FdConstants::eTotal)
    { fLightProfile->AddTabulatedFunctionErrors(source); }

    bool HasLightFlux(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fLightProfile->HasLabel(source); }

    typedef utl::MultiTabulatedFunctionErrors::Iterator MultiLightFluxIterator;
    typedef utl::MultiTabulatedFunctionErrors::ConstIterator ConstMultiLightFluxIterator;

    MultiLightFluxIterator LightFluxesBegin()
    { return fLightProfile->TabulatedFunctionsErrorsBegin(); }
    ConstMultiLightFluxIterator LightFluxesBegin() const
    { return fLightProfile->TabulatedFunctionsErrorsBegin(); }

    MultiLightFluxIterator LightFluxesEnd()
    { return fLightProfile->TabulatedFunctionsErrorsEnd(); }
    ConstMultiLightFluxIterator LightFluxesEnd() const
    { return fLightProfile->TabulatedFunctionsErrorsEnd(); }

    utl::TimeStamp GetPhotonsStartTime() const { return fTraceStartTime; }

    void SetPhotonsStartTime(const utl::TimeStamp& ts)
    { fTraceStartTime = ts; }

    evt::ShowerFRecData& GetFRecShower()
    { return *fShowerData; }
    const evt::ShowerFRecData& GetFRecShower() const
    { return *fShowerData; }
    void MakeFRecShower();
    bool HasFRecShower() const { return bool(fShowerData); }
    
    // profile constraint data

    void SetPCGF(const std::vector<PCGFData>& pcgf) { fPCGF = pcgf; }
    const std::vector<PCGFData>& GetPCGF() const {return fPCGF; }

    
  private:
    EyeRecData(const unsigned int eyeId);
    ~EyeRecData();

    unsigned int fEyeId;

    //utl::Plane fSDP;       // Plane not yet implemented

    double fZeta;

    utl::AxialVector fSDP;
    double fSDPThetaError;
    double fSDPPhiError;
    double fSDPThetaPhiCorrelation;
    double fSDPFitChiSquare;
    unsigned int fSDPFitNDof;

    double fTZero;
    double fTZeroError;
    double fChiZero;
    double fChiZeroError;
    double fRp;
    double fRpError;
    double fRpTZeroCorrelation;
    double fRpChi0Correlation;
    double fChi0TZeroCorrelation;
    double fTimeFitChiSquare;
    unsigned int fTimeFitNDof;

    double fNorthEastCorrelation;
    double fNorthThetaCorrelation;
    double fNorthPhiCorrelation;
    double fNorthTCoreCorrelation;
    double fEastThetaCorrelation;
    double fEastPhiCorrelation;
    double fEastTCoreCorrelation;
    double fThetaPhiCorrelation;
    double fThetaTCoreCorrelation;
    double fPhiTCoreCorrelation;
    double fAxisFitChiSquare;
    unsigned int fAxisFitNDof;


    InternalPixelContainer fPulsedPixels;


    InternalPixelContainer fSDPPixels;


    InternalPixelContainer fTimeFitPixels;

    std::vector<CoordinateData> fCoordinateData;

    utl::InitializedShadowPtr<utl::MultiTabulatedFunctionErrors> fLightProfile;
    utl::TimeStamp fTraceStartTime;

    utl::LameShadowPtr<evt::ShowerFRecData> fShowerData;
    std::vector<PCGFData> fPCGF;
    
    friend class Eye;
    friend class utl::ShadowPtr<EyeRecData>;

  };

}


#endif