G/ApertureLight.h

Go to the documentation of this file.

#ifndef _FdProfileConstrainedGeometryFitPG_ApertureLight_h
#define _FdProfileConstrainedGeometryFitPG_ApertureLight_h


#include <fwk/VModule.h>
#include <fevt/FdConstants.h>
#include <evt/Event.h>
#include <utl/Vector.h>
#include <utl/AugerUnits.h>
#include <map>
#include <vector>

using utl::CoordinateSystemPtr;
using namespace utl;

namespace fevt {
  class Eye;
  class Telescope;
}

namespace fdet {
  class Pixel;
  class Telescope;
}

namespace utl {
  class TabulatedFunctionErrors;
}


namespace FdProfileConstrainedGeometryFitPG {

  // auxillary class for light flux loop
  class ShowerGeometryData {

  public:
    // time bin start
    unsigned int fT1;
    // time bin stop
    unsigned int fT2;

    // index within ADC trace
    unsigned int fADCTraceIndex;

    // chi_i vector at tMean
    double fChiVecMean[3];

    // telescope flux and variance sums
    double fTelFluxSum;
    double fTelVarianceSum;
    double fTelBgVarianceSum;

    // Eye flux and variance sums
    double fEyeFluxSum;
    double fEyeVarianceSum;
    double fEyeBgVarianceSum;

    // For calculating the time ranges that are valid
    // for efficiency-less profile reconstruction
    bool fNearBorder;

    // The set of pixel ids in zeta at the given time
    std::vector<unsigned int> fPixelsInZeta;

    // Flag whether the bin is part of the time fit
    bool fUsedForTimeFit;
  };


  class ApertureLight {

    enum eModeOfOperation {
      ePerEye,
      ePerTelescope,
      ePerEyeAndTelescope
    };

  public:

    bool Init();
    bool Run(evt::Event& event);
    void SetStripMode(bool strip=true) { fStripMode = strip; }

  private:

    bool FindLightFlux(fevt::Eye& eye);

    int fVerbosity;
    //bool fEyeModeAllowTimeOverlap; // unused. LN.
    //bool fStopZetaAtBorder; // unused. LN.
    //bool fTelModeStopZetaAtBorder; // unused. LN.
    //bool fEyeModeStopZetaAtBorder; // unused. LN.
    //eModeOfOperation fConfigMode; // unused. LN.
    //eModeOfOperation fMode; // unused. LN.
    double fmaxZetaAngle;
    double fminZetaAngle;
    double fstepZetaAngle;
    double fSafetyMargin;
    double fBorderMargin;

    bool fStripMode;

    std::map<unsigned short, std::vector<ShowerGeometryData> > fShowerGeometryData;

    bool IsNearBorder(const utl::Vector& direction,
                      const fevt::Telescope& telescope,
                      double zeta) const;

    double FindZeta( fevt::Eye& eye,
                     double initZeta,
                     double finZeta,
                     double stepZeta,
                     bool fillFlux=false );

    utl::TabulatedFunctionErrors&
    GetClearedTelescopeLightFlux( fevt::Telescope& tel,
                                  const fevt::FdConstants::LightSource source );

    utl::TabulatedFunctionErrors&
    GetClearedEyeLightFlux( fevt::Eye& eye,
                            const fevt::FdConstants::LightSource source );

    void FillEyeFluxes(fevt::Eye&,
                       const std::vector<double> &,
                       const std::vector<double> &,
                       const std::vector<double> &,
                       const std::vector<double> &,
                       const std::vector<double> &);

    void FillTelescopeFluxes(fevt::Telescope&,
                             const std::vector<double> &,
                             const std::vector<double> &,
                             const std::vector<double> &,
                             const std::vector<double> &,
                             const std::vector<double> &,
                             const std::vector<const std::vector<unsigned int>*> &,
                             const std::list<std::pair<double, double> > &);

    void FillFluxes(utl::TabulatedFunctionErrors&,
                    utl::TabulatedFunctionErrors&,
                    utl::TabulatedFunctionErrors&,
                    const std::vector<double> &,
                    const std::vector<double> &,
                    const std::vector<double> &,
                    const std::vector<double> &,
                    const std::vector<double> &);

    bool CalculateShowerGeometryData(const fevt::Eye& eye);

  private:
    /* nested class representing the latest telescope times for sorting */
    class LastTelTime {
    public:
      LastTelTime(unsigned int telid, unsigned int lasttime) : fTelId(telid), fLastTime(lasttime) {}
      unsigned int fTelId;
      unsigned int fLastTime;
      static bool TelescopeTimeCmp(LastTelTime a, LastTelTime b) { return a.fLastTime < b.fLastTime; }
    };

  };

} //namespace;

#endif