FdApertureLightFinderKG/FdApertureLightFinder.h

Go to the documentation of this file.

#ifndef _FdApertureLightFinderKG_FdApertureLightFinder_h_
#define _FdApertureLightFinderKG_FdApertureLightFinder_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 FdApertureLightFinderKG {

  // auxillary class for light flux loop
  class ShowerGeometryData {

  public:
    // time in ns of start
    double fT1;
    // time in ns of stop
    double 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 FdApertureLightFinder : public fwk::VModule {

    enum eModeOfOperation {
      ePerEye,
      ePerTelescope,
      ePerEyeAndTelescope
    };

  public:
    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish() { return eSuccess; }

  private:
    bool FindLightFlux(fevt::Eye& eye);

    int fVerbosity = 0;
    //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;
    bool fOnlyUsedForTimeFit;

    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; }
    };

    REGISTER_MODULE("FdApertureLightKG", FdApertureLightFinder);

  };

}


#endif