FdProfileReconstructor.h

Go to the documentation of this file.

#ifndef _FdProfileReconstructorKG_FdProfileReconstructor_h_
#define _FdProfileReconstructorKG_FdProfileReconstructor_h_

#include <deque>
#include <vector>
#include <map>
#include <utl/Vector.h>
#include <utl/Point.h>
#include <utl/TabulatedFunction.h>
#include <utl/PhysicalFunctions.h>

#include <fwk/VModule.h>
#include "CherenkovFluorescenceMatrix.h"
#include "OpticalHalo.h"

namespace fevt{
  class Eye;
}
namespace evt{
  class ShowerFRecData;
}



namespace FdProfileReconstructorKG {

  class EnergyFitter;
  class RootCFMatrixOutput;

  class FdProfileReconstructor :public fwk::VModule{

  public:
    FdProfileReconstructor();
    ~FdProfileReconstructor();

    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish();

    // stuff for SuperModule-mode
    void SetFluorescenceYieldScaleFactor(const double f)
    { fFfac = f; }
    void SetCherenkovYieldScaleFactor(const double f)
    { fCfac = f; }
    double GetFluorescenceYieldScaleFactor() const
    { return fFfac; }
    double GetCherenkovYieldScaleFactor() const
    { return fCfac; }

    void SetPropagateGeometryErrors(const bool propagate)
    { fPropagateGeometryErrors = propagate; }
    void SetPropagateAtmUncertainties(const bool propagate)
    { fPropagateAtmUncertainties = propagate; }
    bool GetPropagateGeometryErrors() const
    {return fPropagateGeometryErrors; }
    bool GetPropagateAtmUncertainties() const
    {return fPropagateAtmUncertainties; }

    void SetInclinedModelDepthBinning(const double dX)
    { fInclinedModelDepthBinning = dX; }

    void SetYieldRefit(bool what);
    void SetAlwaysGuessXMaxFromAperture(const bool what)
    { fAlwaysGuessXMaxFromAperture = what; }

    void SetVerbosity(const int verbosity)
    { fVerbosity = verbosity; }
    void SetEnergyFitterVerbosity(int verbosity);
    void SetErrorPropagationVerbosity(const int verbosity)
    { fErrPropVerb = verbosity; }
    int GetVerbosity() const
    { return fVerbosity; }
    int GetErrorPropagationVerbosity() const
    { return fErrPropVerb; }
    int GetEnergyFitterVerbosity() const;

  private:
    void InitProfiles(fevt::Eye& eye);
    bool InitializeAtmosphere(const bool flatEarth,
                              double& minDist,
                              double& maxDist);
    bool GetShowerFRecData(evt::Event& event, fevt::Eye& eye);
    bool CalculateProfiles(fevt::Eye& eye);
    bool CalculateGeometryAndDepth(fevt::Eye& eye);
    void CalculateDetEff(const fevt::Eye& eye);
    void AddPointsOutsideFOV();
    double GuessShowerMaximum(evt::Event& event, const fevt::Eye& eye);
    void DeleteCFMatrix();

    // functions used in error propagation
    bool PropagateUncertainties(fevt::Eye& eye);
    void CalculateTotalErrors(fevt::Eye& eye);
    void SetGeometry(fevt::Eye& eye, double nSigRp, double nSigChi0,
                     double nSigT0, double nSigPhi, double nSigTheta);
    bool ReFitProfile(fevt::Eye& eye, double nSigRp, double nSigChi0,
                      double nSigT0,  double nSigPhi, double nSigTheta,
                      std::vector<std::vector<double> >& results);

    enum EShowerParameters {
      eX0 = 0,
      eXmax,
      edEdXmax,
      eLambda,
      eEem,
      eNFitParameters
    };

    // options for invisible energy
    utl::InvisibleEnergy::ECompositionModel fComposition;
    utl::InvisibleEnergy::EInteractionModel fInvisibleEnergyModel;

    // XML options
    double fEcut;      // lower energy cut off for this calculation
    int fVerbosity;    // controls print level for Profile reconstructor
    int fErrPropVerb;  // controls print level for error propagation
    int fPropagateGeometryErrors; // geometrical error calculation
    int fPropagateAtmUncertainties; // atmospheric error calculation
    int fRescaleErrors; // rescaling errors according to PDG fudge
    int fmaxErrPropPoints; // max number of points to be used during err. prop.
    double fCfac; // scale factor for Cherenkov light
    double fFfac; // scale factor for Fluorescence light
    double fInclinedModelMaxCosZenith ; // min. angle for inclined profile model
    double fInclinedModelDepthBinning;

    // options for lateral shower light width
    CherenkovFluorescenceMatrix::eFluorescenceLDF       fFluoLDF;
    CherenkovFluorescenceMatrix::eDirectCherenkovLDF    fDirCherLDF;
    CherenkovFluorescenceMatrix::eScatteredCherenkovLDF fScatCherLDF;
    CherenkovFluorescenceMatrix::eMultipleScatteringLDF fMultScatLDF;
    bool fCherenkovCone;
    OpticalHalo::EHaloType fOpticalHalo;

    bool fYieldRefit;
    bool fAlwaysGuessXMaxFromAperture;
    bool fIsMultiEyeEvent;

    bool fSaveToRoot;

    // data members
    double fXmax; // current guess of shower maximum
    std::deque<double> fDepth; // vector of slant depths
    utl::TabulatedFunction fRelEff; // vector of relative detector effs
    evt::ShowerFRecData* fShowerFRecData; // either global or eye data
    unsigned int fOutSideFOV; // points outside field of view

    // current Cherenkov-Fluorescence matrix
    CherenkovFluorescenceMatrix* fChFlPtr;
    // Cherenkov-Fluorescence matrix map
    std::map<int, CherenkovFluorescenceMatrix*> fChFlPtrMap;
    // vector of geom. track positions
    std::deque<std::vector<utl::Point> > fTrackPositions;

    EnergyFitter* fEnergyFitter; // object for GH and energy fitting
    double fRp;         // current Rp
    double fChi0;       // current Chi0
    double fT0;         // current T0
    utl::Vector  fAxis; // current axis
    utl::Point   fCore; // current core
    bool fErrorCalcMode;// variable to flag error calculation mode
    std::vector<double> fGeomVariance;   // variances of GH parameters and Eem
    std::vector<double> fAtmVariance;    // variances of GH parameters and Eem

    RootCFMatrixOutput* fRootCFMOutput; // for debugging and visualization

    REGISTER_MODULE("FdProfileReconstructorKG",FdProfileReconstructor);

  };
}


#endif // _FdProfileReconstructorKG_FdProfileReconstructor_h_