UniversalityFitter.h

Go to the documentation of this file.

#ifndef _UniversalityFitter_UniversalityFitter_h_
#define _UniversalityFitter_UniversalityFitter_h_

#include <string>
#include <sstream>
#include <fstream>

#include <fwk/VModule.h>

#include "UnivRecNS/UnivRec.h"
#include "UnivFitterKG/UnivFitterKG.h"

namespace utl {
  class RandomEngine;
}

namespace mdet {
  class Scintillator;
}

namespace UniversalityFitter {

  enum StationType {
    eWCD,
    eASCII,
    eAMIGA
  };

  struct StationFitData {
  public:
    StationFitData(): stationId(0), stationType(eWCD), totalSignal(0), isSaturated(false),
      useUnsaturatedTrace(false), isSilent(false),
      AreaOverPeak(0), startBin(0), stopBin(0), t10(0), t50(0), t90(0) {};

    int stationId;
    StationType stationType;
    double totalSignal;
    bool isSaturated;
    bool useUnsaturatedTrace;
    bool isSilent;
    double AreaOverPeak;
    double DetectorArea;

    std::vector<double> trace;

    utl::TimeStamp startTime;
    int startBin;
    int stopBin;

    double t10;
    double t50;
    double t90;

    utl::Point position;
  };

  struct FDParameters {
  public:
    FDParameters(): xmax(0), energy(0) {};

    std::string eyeName;
    double xmax;
    double xmaxUnc;
    double energy;
    double energyUnc;
    utl::Vector axis;
    utl::Point core;
    utl::TimeStamp coretime;
  };

  class MCParameters {
  public:
    MCParameters()
    {
      reset();
    };
    void reset()
    {
      xmax = 0;
      x0 = 0;
      Nmu = 0;
      energy = 0;
    }

    double xmax;
    double xmaxMu;
    double x0;
    double Nmu;
    double energy;
    utl::Vector axis;
    utl::Point core;
    utl::TimeStamp coretime;
  };

  class FittedParameters {
  public:
    FittedParameters()
    {
      reset();
    };
    void reset()
    {
      isGoodRec = false;
      xmax = 0;
      x0 = 0;
      Nmu = 0;
      energy = 0;
      xmaxUnc = 0;
      x0Unc = 0;
      NmuUnc = 0;
      energyUnc = 0;
      TimeModelOffset = 0;
      TimeModelOffsetUnc = 0;
    }

    bool isGoodRec;

    double xmax;
    double xmaxUnc;

    double x0;
    double x0Unc;

    double Nmu;
    double NmuUnc;

    double energy;
    double energyUnc;

    double TimeModelOffset;
    double TimeModelOffsetUnc;

    utl::Vector axis;
    double axisUncTheta;
    double axisUncPhi;

    utl::Point core;
    double coreUncX;
    double coreUncY;

    utl::TimeStamp coretime;

    int fNCandShape;
    int fNCandStartTime;
    int fNCandLDF;
  };

  struct KarlsruheConfig {
  public:
    KarlsruheConfig() {};

    int RecType;
    int TimeModelVersion;
    bool useSmearedMC;
    bool useRealisticEnergySmearing;
    std::string outputFileName;
  };

  struct BarilocheConfig {
  public:
    BarilocheConfig() {};

    std::string outputFileName;
    bool IsData;
    bool RecSDEUpgrade;
    int RecType;
    int RecDetector;
    int RecSys;
    int verbose;
    int debug;
  };

  // global for use by TMinuit
  static std::unique_ptr<UnivRecNS::UnivRec> gUnivRecNS;
  static std::vector<int> parStatus;

  class UniversalityFitter : public fwk::VModule {

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

    void SwitchMethod();

  private:

    double fMinTheta, fMaxTheta;
    double fMinEnergy;

    bool fSkipNonT5;
    int fSelectedEye;
    bool fSkipXmaxBelowGround;
    double fMinDXground;
    bool fSkipXmaxOutsideProfile;
    int fMinBinsAroundMaximum;
    double fSilentMaxRadius;
    std::string fActiveMethod;
    bool fWriteToTextFile;

    bool fUseUnsaturatedTrace;

    int fCalibOpt;
    int fRecMixture;

    KarlsruheConfig fKarlsruheConfig;
    BarilocheConfig fBarilocheConfig;

    std::ofstream fitInfoKG;
    std::ofstream fitInfoBG;

    utl::RandomEngine* fRandomEngine;

    double fDensity;
    bool fEventHasSaturation;

    //0: "combined", 1: "Los Leones", 2: "Los Morados", 3: "Loma Amarilla", 4: "Coihueco", 5: "Heat", 6: "HECO"
    std::map<int, FDParameters> fdParameters;

    MCParameters mcPars;
    MCParameters mcParsFluct;
    FittedParameters fittedPars;

    std::vector<StationFitData> fStations;
    StationFitData* fHottestStation;
    double fHottestStationHeight;

    void RunKarlsruheReconstruction(evt::Event& event);

    bool InitBarilocheReconstruction(evt::Event& event);
    void RunBarilocheReconstruction(evt::Event& event);

    double SmearValue(double mean, double spread);

    void SetRecData(evt::Event& event);
    void WriteRecParameters(evt::Event& event);

    // the same object is used for all events (creating the fitter instance is rather slow)
    std::unique_ptr<UnivFitterKG::Fitter> fFitterKG;

    static void UnivRecNS_FCN(Int_t& npar, Double_t* gin, Double_t& f, Double_t* par, Int_t iflag);
    bool Rec(UnivRecNS::UnivRec& theRec);

    REGISTER_MODULE("UniversalityFitter", UniversalityFitter);

  };

}


#endif