RdLDFFitter.h

Go to the documentation of this file.

#ifndef _RdLDFFitter_h_
#define _RdLDFFitter_h_

#include <fwk/VModule.h>
#include <rdet/RDetector.h>
#include <revt/REvent.h>
#include <utl/CoordinateSystemPtr.h>
#include "LikelihoodFunction.h"
#include "Minuit2/MnUserCovariance.h"

namespace evt {
  class Event;
}

namespace revt {
  class Station;
}

namespace utl {
  class AnalyticFilter;
}

// you should assign your module to a namespace

namespace RdLDFFitter {

  struct ParameterLDFModel {
    double A;
    double AError;
    double R0;
    double R0Error;

    ParameterLDFModel() :
        A(0), AError(0), R0(0), R0Error(0)
    {
    }
  };

  struct ParameterScintillatorLDFModel {
    int status;
    double N_e;
    double N_eError;
    double Rm;
    double RmError;
    ParameterScintillatorLDFModel() :
      status(0), N_e(0), N_eError(0), Rm(0), RmError(0)
    {
    }
  };

  enum InfoLevel {
    eNone = 0, eFinal = 1, eIntermediate = 2, eObscure = 3, eDebug = 4
  };
  enum ScanCenter {
    eRadio = 0, eSD = 1, eFD = 2, eMC = 3
  };

  class RdLDFFitter: public fwk::VModule {

  public:
    // If you define a constructor, you MUST provide an implementation
    // for it, otherwise the REGISTER_MODULE macro will not register
    // your module. (Here, implementation is in RdLDFFitter.cc)
    RdLDFFitter();
    virtual ~RdLDFFitter();

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

  private:

    ParameterLDFModel PreLDFFit(int LDFModel, const std::vector<StationFitData>& vStationFitData,
        utl::Vector ShowerAxis, utl::Point CorePosition);

    ParameterScintillatorLDFModel PreScintillatorLDFFit(const std::vector<ScintillatorFitData>& vScintillatorData,
                                            utl::Vector ShowerAxis, utl::Point CorePosition);



    fwk::VModule::ResultFlag SaveContours(unsigned int runNumber, const int eventId,
        const std::vector<std::pair<double, double> > contour,
        const std::vector<std::pair<double, double> > contour2, ROOT::Minuit2::MnUserCovariance cov,
        const double coreX, const double coreY);

    utl::Point Scan(std::vector< std::vector<double> >& scanResult,
                                  const LDFLikelihoodFunction L,
                                  const utl::Point core,
                                  const unsigned int nStepsX, const unsigned int nStepsY,
                                  const double widthX, const double widthY, const double a);

    utl::Point Scan(std::vector< std::vector<double> >& scanResult,
                                  const LDFLikelihoodFunction L,
                                  const utl::Point core,
                                  const unsigned int nSteps,
                                  const double width, const double a) {
      return Scan(scanResult, L, core, nSteps, nSteps, width, width, a);
    }

    fwk::VModule::ResultFlag SaveScan(const std::vector< std::vector<double> >& scanResult,
                                       const std::string filename,
                                       const double coreX, const double coreY,
                                       const unsigned int nStepsX, const unsigned int nStepsY,
                                       const double widthX, const double widthY);
    fwk::VModule::ResultFlag PlotScan(const std::vector<std::vector<double> >& scanResult,
                                      const std::string filename,
                                      const utl::Point scanCenter, const utl::CoordinateSystemPtr cs,
                                      const utl::Point coreSd, const utl::Point coreRd,
                                      const unsigned int nStepsX, const unsigned int nStepsY,
                                      const double widthX, const double widthY,
                                      const std::vector<StationFitData>& vStationFitData,
                                      const EventFitData& eventFitData, const double a);

    std::vector<std::pair<double, double> > GetAnglesToLorentzVector();

    std::vector<std::pair<double, double> > GetAnglesToEFieldExpectation(const utl::Point core, const double a);

    fwk::VModule::ResultFlag PlotGoodnessOfFit(const std::string folder,
                                                 const std::string eventIdentifier,
                                                 const utl::Point core);

    double GetEnergy(const double energy_estimator);

    // The REGISTER_MODULE macro makes the framework aware of your module.
    // You need to put this macro at the very end of your module class definition.
    // Give your module a name (first argument) and specify its 
    // class name (second argument).  In the ModuleSequenceExample.xml file,
    // you can see this module being refered to by the name we give it here.

    FitConfig fFitConfig;

    int fInfoLevel;

    utl::CoordinateSystemPtr fLocalCS;

    bool fSaveContour; // if true the 68% and 95% confidence contours are calculated using MnContour (MINOS) (Warning: this procedure needs a lot of computing resrouces)
    bool fPerformScan;  // perform a "time consuming" scan of the Likelihood function
    bool fPlotSigmaContours; // if true the color scale in the TH2D is adjusted to correspond with the "sigma" regions
    unsigned int fNStepsX, fNStepsY;  // number of steps in x/y direction
    double fStepWidthX, fStepWidthY;  // step width
    ScanCenter fScanCenter; // center of scan, can be e.g. SD core position
    double fMCUncertaintyOnEFieldVector; // the measured efield vector is artificially smeared according to a Fisher-Distribution

    const short fPlotStyle;  // 0 = Release, 1 = Debug

    const revt::REvent* fREvent;
    const evt::Event* fConstEvent;
    evt::Event* fEvent;
    utl::Vector fShowerAxis;
    utl::Vector fMagneticFieldAxis;

    std::string fOutputFolder;


  REGISTER_MODULE("RdLDFFitter", RdLDFFitter);

  };

}

#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -k"
// End: