CherenkovFluorescenceMatrix.h

Go to the documentation of this file.

#ifndef _CherenkovFluorescenceMatrix_h_
#define _CherenkovFluorescenceMatrix_h_

#include "OpticalHalo.h"
#include <utl/Point.h>
#include <utl/TabulatedFunction.h>
#include <deque>
#include <vector>


namespace oBLAS {
  class diagonalMatrix;
  class lowerTriangularMatrix;
}

namespace FdProfileReconstructorKG {

  class CherenkovFluorescenceMatrix {

  public:
    enum eFluorescenceLDF {
      eNoFluoLDF,
      eGoraFluoLDF
    };

    enum eDirectCherenkovLDF {
      eNoDirCherLDF,
      eGoraDirCherLDF
    };

    enum eScatteredCherenkovLDF {
      eNoScatCherLDF,
      eGoraScatCherLDF,
      eExpoScatCherLDF,
      eGillerScatCherLDF
    };

    enum eMultipleScatteringLDF {
      eNoMultScatLDF,
      eRobertsLDF,
      ePekalaLDF
    };

  public:
    CherenkovFluorescenceMatrix(const double xMax, const utl::Point& eyePos,
                                const std::deque<std::vector<utl::Point>>& showerGeometry,
                                const utl::TabulatedFunction& relEff,
                                const std::deque<double>& depth, const double eCut,
                                const double zeta, const double Cfac, const double Ffac,
                                const eFluorescenceLDF f, const eDirectCherenkovLDF dc,
                                const eScatteredCherenkovLDF sc, const eMultipleScatteringLDF ms,
                                const bool cherenkovCone,
                                const OpticalHalo::EHaloType spotHalo);

    ~CherenkovFluorescenceMatrix();

    const oBLAS::lowerTriangularMatrix* GetMieScatteredCherenkovMatrix() const
    { return fMieScatteredCherenkovMatrix; }
    const oBLAS::lowerTriangularMatrix* GetRayleighScatteredCherenkovMatrix() const
    { return fRayleighScatteredCherenkovMatrix; }
    const oBLAS::diagonalMatrix* GetDirectCherenkovMatrix() const
    { return fDirectCherenkovMatrix; }
    const oBLAS::diagonalMatrix* GetFluorescenceMatrix() const
    { return fFluorescenceMatrix; }
    const oBLAS::lowerTriangularMatrix* GetCherenkovFluorescenceMatrix() const;

    const std::deque<double>* GetDepth() const { return &fDepth; }
    const std::deque<std::vector<utl::Point>>& GetGeometry() const
    { return fShowerGeometry; }

    const std::vector<double>& GetFluorescenceMSFactor() const
    { return fFluorescenceMultipleScattering; }
    const std::vector<double>& GetCherenkovMSFactor() const
    { return fCherenkovMultipleScattering; }

    void Print(const int iwhat) const;
    void UpdateXmax(const double);

    double GetXmax() const { return fXmax; }
    double GetEcut() const { return fEcut; }

    void SetYieldFactors(const double fluoFac, const double chkovFac);

    void SetZeta(const double z);

    double GetZetaDistance(const int ) const;

  private:
    // calculation of CF-matrix ingredients
    void CalculateWaveLengths();
    void CalculateAttenuationToEye();
    void CalculateAttenuationAlongTrack();
    void CalculateGeometricalFactor();
    void CalculateScatteringToEye();
    void CalculateCherenkovAtTrack();

    void CalculateFluorescenceMatrix();
    void CalculateDirectCherenkovMatrix();
    void CalculateMieAndRayScattCherenkovMatrix();
    void CalculateMeanEnergyDeposit();

    // LDF related
    double FluorescenceLDFFraction(const int) const;
    double DirectCherenkovLDFFraction(const int) const;
    double ScatteredCherenkovLDFFraction(const int, const int) const;
    double GoraFraction(const int) const;
    double ExponentialFraction(const int) const;
    double GillerFraction(const int, const int) const;
    double AngularCherenkovCDFWithCone(const double maxEmissionAngle,
                                       const double xVert, const double showerAge) const;

    double RobertsFraction(const int, const std::vector<double>&,
                           const utl::TabulatedFunction&) const;
    double PekalaFraction(const int, const std::vector<double>&,
                          const utl::TabulatedFunction&) const;
    double MultipleScatteringFraction(const int, const std::vector<double>&,
                                      const utl::TabulatedFunction&) const;
    double SpotFraction() const;

    // data members

    // Mie scattered Cherenkov light matrix
    oBLAS::lowerTriangularMatrix* fMieScatteredCherenkovMatrix = nullptr;
    // Rayleigh scattered Cherenkov light matrix
    oBLAS::lowerTriangularMatrix* fRayleighScatteredCherenkovMatrix = nullptr;
    // direct Cherenkov light matrix
    oBLAS::diagonalMatrix* fDirectCherenkovMatrix = nullptr;
    // fluorescence light matrix
    oBLAS::diagonalMatrix* fFluorescenceMatrix = nullptr;
    // total light matrix
    oBLAS::lowerTriangularMatrix* fCherenkovFluorescenceMatrix = nullptr;

    // input quantities
    double fXmax = 0;
    // lower energy cutoff
    double fEcut = 0;
    const utl::Point& fEyePosition;
    const std::deque<std::vector<utl::Point>>& fShowerGeometry;
    std::vector<utl::Point> fShowerPoints;
    const utl::TabulatedFunction& fRelEff;
    const std::deque<double>& fDepth;

    // wavelengths to be used for Cherenkov
    std::vector<double> fCWaveLength;
    // wavelengths to be used for Fluorescence
    std::vector<double> fFWaveLength;

    // transmission vectors
    std::vector<std::vector<double>> fCT2eye; // as function of Cherenkov wave length
    std::vector<std::vector<double>> fFT2eye; // as function of Fluorescence wave length
    std::vector<std::vector<double>> fTShower;
    // scattering towards eye
    std::vector<std::vector<double>> fMieScat2eye;
    std::vector<std::vector<double>> fRayScat2eye;
    // Cherenkov light at track
    std::vector<std::vector<double>> fCherAtTrack;
    // geometrical factors
    std::vector<double> fGfac;
    std::vector<double> fMeandEdX;
    // multiple scattering factors
    std::vector<double> fFluorescenceMultipleScattering;
    std::vector<double> fCherenkovMultipleScattering;

    mutable bool fUpToDate = false;

    double fZeta = 0;
    double fTanZeta = 0;  // tangens of the S/N zeta value (<=0 --> no correction)
    double fCfac = 0;  // scale factor for Cherenkov light
    double fFfac = 0;  // scale factor for Fluorescence light

    eFluorescenceLDF fFluoLDF = eNoFluoLDF;
    eDirectCherenkovLDF fDirCherLDF = eNoDirCherLDF;
    eScatteredCherenkovLDF fScatCherLDF = eNoScatCherLDF;
    eMultipleScatteringLDF fMultScatLDF = eNoMultScatLDF;
    bool fCherenkovCone = false;
    OpticalHalo fOpticalHalo;
  };

}


#endif