MMAdvancedCalibrationProcessor.h

#ifndef MMADVANCEDCALIBRATIONPROCESSOR_H 
#define MMADVANCEDCALIBRATIONPROCESSOR_H 

#include <marlin/Processor.h>
#include <lcio.h>
#include <string>
#include <map>
#include <vector>

#include "MMPadResponseFunction.h"

//LCIO
#include "lcio.h"
#include "EVENT/LCCollection.h"
#include "IMPL/LCCollectionVec.h"
#include "EVENT/TrackerPulse.h"

//Aida
#include <AIDA/AIDA.h>
#include <marlin/AIDAProcessor.h>
#include <AIDA/ITupleFactory.h>
#include <AIDA/ITuple.h>
#include <AIDA/IHistogramFactory.h>
#include <AIDA/IHistogram1D.h>
#include <AIDA/IHistogram2D.h>

//LCIO
#include <EVENT/LCFloatVec.h>
#include <IMPL/TrackerDataImpl.h>
#include <IMPL/TrackerPulseImpl.h>
#include <IMPL/TrackerHitImpl.h>
#include <IMPL/TrackImpl.h>

// GEAR
#include <gear/TPCParameters.h>
#include <gear/TPCModule.h>
#include <gearimpl/GlobalPadIndex.h>

//MARLIN
#include <marlin/Global.h>

//ROOT
#include <Minuit2/MnUserParameters.h>
#include <Minuit2/MnMigrad.h>
#include <Minuit2/FunctionMinimum.h>
#include <Minuit2/Minuit2Minimizer.h>

#include "Math/Minimizer.h"
#include "Math/Functor.h"
#include <TMath.h>
#include <TTree.h>
#include <TH2D.h>
#include <TH2F.h>
#include <TH1F.h>
#include <TF1.h>
#include <TCanvas.h>
#include <TApplication.h>

namespace marlintpc
{
  class MMAdvancedCalibrationProcessor : public marlin::Processor
  {
    public:

      virtual Processor*  newProcessor() { return new MMAdvancedCalibrationProcessor; }

      MMAdvancedCalibrationProcessor();

      virtual void init();

      virtual void processRunHeader(EVENT::LCRunHeader* run);

      virtual void processEvent(EVENT::LCEvent* evt);

      virtual void check(EVENT::LCEvent* evt);

      virtual void end();

    protected:

      //Required Parameters
      lcio::StringVec           _inputColNames; // Name of the input collection
      std::string                                       _output_path;
      std::string                               _source;
      std::string                               _type;
      std::string                               _prfType;
      int                                                               _trackType;

      std::vector<float> _stepVec;
      std::vector<float> _minVec;
      std::vector<float> _maxVec;
      std::vector<float> _startVec;


      //Optional Parameters
      double                                                    _tolerance;
      int                                                               _iter;
      int                                                               _fcn;
      int                                                               _normType;
      bool                                                              _fitOutput;
      bool                                                              _rowDep;
      bool                                                              _fitTrack;
      bool                                                              _padHits;
      std::vector<int>    _moduleList;

      //Class Variables
      int                                                               _curEvt; //Keep track of the current event.
      int                                                               _nPar;
      bool                                                              _moduleDep;

      AIDA::ITuple*             _fitData;
      AIDA::ITuple*             _hitData;

      TTree*                                                    _tree;
      std::vector< TH1F * >     _histogramPar;
      std::vector< std::vector<TH2F *> >        _histogramCorrPar;

      ROOT::Math::Minimizer* min;

  };
} // namespace marlintpc
#endif // MMADVANCEDCALIBRATIONPROCESSOR_H