ScintillatorLDFFinder.h

Go to the documentation of this file.

#ifndef _ScintillatorLDFFinderKG_ScintillatorLDFFinder_h_
#define _ScintillatorLDFFinderKG_ScintillatorLDFFinder_h_

#include <fwk/VModule.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include <utl/CovarianceMatrix.h>

#include <cmath>
#include <sstream>

#include "LDF.h"
#include "LikelihoodFunctions.h"

namespace evt {
  class Event;
}

namespace sevt {
  class SEvent;
}

namespace ScintillatorLDFFinderKG {

  utl::CoordinateSystemPtr gBaryCS; // is used by LikelihoodFunctions, too


  class ScintillatorLDFFinder : public fwk::VModule {
  public:
    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish();

    enum InfoLevel {
      eNone = 0,
      eFinal = 1,
      eIntermediate = 2,
      eObscure = 3,
      eMinuit = 4
    };

    enum LDFParameter {
      eShowerSize = 0,
      eCoreX = 1,
      eCoreY = 2,
      eShapeParameters = 3
    };

    struct LDFFitResult {

      LDFFitResult(const LDFFitConfig& config) :
        fPar(eShapeParameters + config.fLDF.GetNShapeParameters()),
        fCov(fPar.size()),
        fChi2(0),
        fNdof(0),
        fLogLikelihood(0),
        fRecStage(0)
      { }

      std::vector<double> fPar;
      utl::CovarianceMatrix fCov;

      double fChi2;
      int fNdof;
      double fLogLikelihood;
      double fRecStage;

      // for convenience

      utl::Point GetCore() const
      { return utl::Point(fPar[eCoreX], fPar[eCoreY], 0, gBaryCS); }

      std::vector<double> GetLDFShapeParameters() const
      { return std::vector<double>(fPar.begin() + eShapeParameters, fPar.end()); }

    };

  private:
    // LDF part
    bool FixBeta(const LDFFitResult& result,
                 const utl::Vector& showerAxis,
                 const std::vector<StationFitData>& data) const;

    bool FixGamma(const LDFFitResult& result,
                  const utl::Vector& showerAxis,
                  const std::vector<StationFitData>& data) const;
    
    void FitLDFSimplified(LDFFitResult& result,
                          LDFFitConfig& config,
                          const utl::Vector& showerAxis,
                          const std::vector<StationFitData>& data) const;

    bool FitLDF(LDFFitResult& result,
                LDFFitConfig& config,
                const utl::Vector& showerAxis,
                const std::vector<StationFitData>& data) const;
    // other
    std::vector<StationFitData> MakeStationFitData(const sevt::SEvent& sEvent, 
                                                   const utl::Point core, 
                                                   const double showerSize, 
                                                   const utl::Vector& showerAxis) const;

    void SetRecData(evt::Event& event,
                    const LDFFitResult& lresult) const;

    void OutputResults(const evt::Event& event) const;

    // vars
    int fInfoLevel;
    double fMaxBaryToCoreDistance;
    double fMaxChi2;
    bool fUseMaxLikelihood;
    bool fFixedCore;
    bool fCorePropagation;
    
    utl::Point fBarycenter;
    utl::TimeStamp fBaryTime;
    LDFFitConfig fLDFFitConfig;
    
    struct Stage0 {
      int fMinNumberOfStations;
    } fStage0;

    struct Stage1 {
      int fMinNumberOfStations;
    } fStage1;

    struct Stage2 {
      int fMinNumberRelaxBeta;
      int fMinNumberRelaxGamma;
    } fStage2;
    
    REGISTER_MODULE("ScintillatorLDFFinderKG", ScintillatorLDFFinder);

  };

}


#endif