LongitudinalXmaxScanner.h

Go to the documentation of this file.

#ifndef _RecDataWriterNG_LongitudinalXmaxScanner_h_
#define _RecDataWriterNG_LongitudinalXmaxScanner_h_

#include <utl/PhysicalConstants.h>
#include <vector>
#include <array>


class RecEvent;
class FDEvent;

namespace utl {
  class TabulatedFunctionErrors;
  class TabulatedFunction;
  class Point;
  class Vector;
}

namespace otoa {

  class LongitudinalScan {
  public:
    LongitudinalScan() { }

    void
    AddScanResult(double depth, double error, double minViewAngle)
    {
      fDepth.push_back(depth);
      fXiXmax.push_back(error);
      fMinViewingAngle.push_back(minViewAngle);
    }

    const std::vector<double>& GetDepthVector() const { return fDepth; }

    const std::vector<double>& GetXiXmaxVector() const { return fXiXmax; }

    const std::vector<double>& GetMinViewingAngleVector() const { return fMinViewingAngle; }

  private:
    std::vector<double> fDepth;
    std::vector<double> fXiXmax;
    std::vector<double> fMinViewingAngle;
  };


  class LongitudinalXmaxScanner {
  public:
    LongitudinalXmaxScanner() { }

    void EstimateXmaxErrors(const RecEvent& theRecEvent);

    const std::vector<LongitudinalScan>& GetLongitudinalScan() const
    { return fLongitudinalScan; }

    const std::vector<double>& GetErrorAtXmax() const
    { return fErrorAtXmax; }

    // use BGLoop variances for NSB?
    void SetUseBGLoop(const bool use) { fUseBGLoop = use; }

  private:
    bool FillLightFactors(const FDEvent&);

    void CalculateXmaxUncertainties(const FDEvent&);

    double CalculateLightFactor(const utl::Point& pos1,
                                const utl::Point& pos2,
                                const unsigned int eyeId) const;

    double CalculateTimeLength(const utl::Point& pos1,
                               const utl::Point& pos2,
                               const unsigned int eyeId) const;

    double CalculateTotalError(const double geomVar,
                               const double profVar,
                               const FDEvent& fdEvent);

    std::vector<unsigned short> CalculatePixelTrigger(const std::vector<double>&) const;

    bool IsTriggered(double dT, double dAng, double npe) const;

    void GetTelescopeProperties(unsigned int);

    double PropagateProfileUncertainty(const FDEvent&, const double X);

    void PropagateGeometryUncertainty(const FDEvent&);

    std::vector<double> GetChangedDepth(const FDEvent&,
                                        double,double,double,double,double);

    void PrintCurrentVariables(const FDEvent&) const;

    std::array<unsigned int, 2> GetTelescopeAndPixelId(const utl::Vector& dir,
                                                       const unsigned int eyeId) const;

    bool IsNearBorder(const utl::Vector& direction,
                      const unsigned int eyeId,
                      const unsigned int tekId,
                      const double zeta) const;

    double EstimateXmaxVariance(const std::vector<double>& X,
                                const std::vector<double>& ghFunc,
                                const std::vector<double>& eY,
                                const double nMax,
                                const double xMax,
                                const double X0,
                                const double lambda) const;

    // ErrorCalculator settings
    int fVerbosity = 0;
    double fDepthBinWidth = 10*utl::g/utl::cm2;

    // detector properties
    double fGainVariance = 0;
    double fPhotonToPhotoElectron = 0;
    double fPixelSize = 0;

    // data from ADSTs
    double fCalorimetricEnergy = 0;
    double fPhotoElectronBGRMS = 0;
    double fShowerAngularLength = 0;
    double fXmax = 0;

    // estimated event properties along shower axis
    std::vector<double> fDepth;
    std::vector<double> fGeomVariance;
    std::vector<double> fTime;
    std::vector<double> fViewingAngle;
    std::vector<double> fDeltaAngle;
    std::vector<double> fDeltaTime;
    std::vector<double> fPhotoElectronFactor;
    std::vector<double> fNoiseVariance;
    std::vector<bool> fCloseToBoundary;
    std::vector<bool> fOutsideTelescope;

    // current track parameters
    unsigned int fBins = 0;
    double fTrackMin = 0;
    double fTrackMax = 0;
    double fMinViewingAngle = 0;
    double fAngularLength = 0;
    double fGeomVarScaleFac = 0;

    // result at X=Xmax
    double fXmaxGeomVar = 0;
    double fXmaxProfVar = 0;
    double fXmaxTotErr = 0;
    double fXmaxAngularLength = 0;

    bool fUseBGLoop = false;

    // final results
    std::vector<LongitudinalScan> fLongitudinalScan;
    std::vector<double> fErrorAtXmax;
  };

}


#endif