ZombieGraveyard/LDFFinderOG/LDFFinder.h

Go to the documentation of this file.

#ifndef _LDFFinderOG_LDFFinder_h_
#define _LDFFinderOG_LDFFinder_h_

#include <fwk/VModule.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include "EnergyConversion.h"
#include "LDFFunctions.h"

namespace utl {
  class RandomEngine;
}

namespace evt {
  class Event;
}

namespace sevt {
  class SEvent;
}


namespace LDFFinderOG {

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

    struct LDFFitInterface {

      LDFFitInterface();

      double fS1000;
      double fS1000Err;
      utl::Point fCore;
      utl::Vector fCoreErr;
      double fErrMatrix[5][5];
      int fFixedBeta;
      double fBeta;
      double fBetaErr;
      bool fFixedGamma;
      double fGamma;
      double fGammaErr;
      double fEnergy;
      double fEnergyErr;
      double fChi2;
      double fNdof;
      double fLikelihood;
      double fRecStage;
      bool fUseSilents;
      double fMaxChi2;
    };

    struct CurvatureFitInterface {

      CurvatureFitInterface();

      utl::Point fCore;
      bool fFixedAxis;
      utl::Vector fAxis;
      utl::Vector fAxisErr;
      double fSigmaU2;
      double fSigmaV2;
      double fSigmaUV;
      bool fFixedRc;
      double fRc;
      double fRcErr;
      double fct0;
      double fct0Err;
    };

  private:
    // LDF part

    void EstimateS1000(LDFFitInterface& fi) const;
    void EstimateEnergy(LDFFitInterface& fi) const;
    double ParameterizedRc(const LDFFitInterface& fi) const;
    double EstimateChi2(const LDFFitInterface& fi) const;
    double EstimateNStationsInFit(const LDFFitInterface& fi) const;
    void EstimateLDF(LDFFitInterface& fi, const utl::Point& core) const;
    void EstimateLDFbySeedStations(LDFFitInterface& fi,
                                   const utl::Point& core) const;
    bool FixBeta(const LDFFitInterface& fi) const;
    bool FixGamma(const LDFFitInterface& fi) const;
    bool FitLDF(LDFFitInterface& fi, const int nStations) const;
    double FitLDFDriver(LDFFitInterface& fi) const;
    static void LDFFitMaxLikeFnc(int& nPar, double* const grad, double& value,
                                 double* const par, const int iFlag);
    static void LDFFitChi2Fnc(int& nPar, double* const grad, double& value,
                              double* const par, const int iFlag);

    // Curvature part
    bool EstimateCurvature(CurvatureFitInterface& fi) const;
    double FitCurvatureDriver(CurvatureFitInterface& fi) const;
    static void CurvatureFitFnc(int& nPar, double* const grad, double& value,
                                double* const par, const int iFlag);

    void SetRecData(evt::Event& event, const LDFFitInterface& lfi,
                    const CurvatureFitInterface& cfi) const;
    void OutputStations(const LDFFitInterface& fi) const;
    void OutputResults(const evt::Event& event) const;

    bool FixCore(const evt::Event& event, Point& core,
                 TimeStamp& coreTime, Vector& axis) const;

    // vars
    static const sevt::SEvent* fgCurrentSEvent;
    static utl::Point fgBarycenter;
    static utl::TimeStamp fgBaryTime;
    static utl::Vector fgShowerAxis;
    static utl::CoordinateSystemPtr fgLocalCS;
    static bool fgUseSilentStations;
    static double fgSilentMaxRadius;
    static double fgSilentRadiusTransition;
    static double fgSilentSignalThreshold;
    static bool fgFixLDF;
    static double fgNoRecovery;
    static bool fgLowerLimit;
    static double fgNKGFermiMu;
    static double fgNKGFermiTau;
    
    int fInfoLevel;
    bool fMinuitOutput;
    int fCoreType;
    double fMaxTheta;
    bool fUseMaxLike;
    double fMaxChi2;
    double fMaxBaryToCoreDistance;
    bool fUseSilentStations;
    double fSilentRadiusTransition;

    int fRoptN;
    utl::RandomEngine* fRandomEngine;
    struct Stage0 {
      int fMinNumberOfStations;
      bool fUseCorePosition;
    } fStage0;

    struct Stage1 {
      int fMinNumberOfStations;
      double fMaxChi2;
    } fStage1;

    struct Stage2 {
      int fMinNumberRelaxBeta;
      int fMinNumberRelaxGamma;
    } fStage2;

    struct Stage3 {
      int fMinNumberOfStations;
      int fMinNumberForFullCurvatureFit;
      double fMaxAxisAngleDifference;
    } fStage3;

    EnergyConversion fEnergyConversion;

    enum InfoLevel {
      eNone = 0,
      eFinal = 1,
      eIntermediate = 2,
      eObscure = 3,
      eMinuit = 4
    };
    
    
  public:
    static LDFFunctionType fgLDFType;

    enum CoreType {
      eMC,
      eHybrid,
      eFit,
    };

    REGISTER_MODULE("LDFFinderOG", LDFFinder);

  };

} // LDFFinderOG


#endif // _LDFFinderOG_LDFFinder_h_

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: