MMRefitTool.h

#ifndef MMREFITTOOL_H
#define MMREFITTOOL_H

// C++
#include <iostream>
#include <string>
#include <vector>
#include <map>

// ROOT
#include "Math/ParamFunctor.h"
#include <Minuit2/FCNBase.h>
#include <TMath.h>

//LCIO
#include "lcio.h"
#include "EVENT/TrackerPulse.h"
#include <EVENT/LCFloatVec.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>

// Other 
#include "MMPadResponseFunction.h"
#include "TrackFitterFactory.h"
#include "TrackFitterBase.h"
#include "LCObjectCopier.h"


namespace marlintpc
{ 

  /*  This is a tool for calculating the chi2 of all the hits in a track, and the track itself. It is used to find the optimal PRF parameters
   *   on an event-by-event basis as a means of calibration.
   *
   *  Author: P. Hayman, Carleton University
   */

        class MMRefitTool : public ROOT::Minuit2::FCNBase
        {

                public:

                        //Fit Type: 0 = straight track
                        //          1 = helical track
                        MMRefitTool(int fitType, int nPar, std::string prfType, bool rowDep, const IMPL::TrackImpl* seed, bool fitTrack, int normType, bool padHits);

                        ~MMRefitTool()
      { 
        trackFitter = NULL;
        std::vector<MMPadResponseFunction>().swap(_prfs);
        std::map<int, int>().swap(_moduleList);
      };
      MMRefitTool( const MMRefitTool& other)
      {
        _fit_type = other._fit_type;
        _nPar = other._nPar;
        _prfType = other._prfType;
        _rowDep = other._rowDep;
        _moduleDep = other._moduleDep;
        _seedTrack = other._seedTrack;
        _fitTrack = other._fitTrack;
        _normType = other._normType;
        _padHits = other._padHits;
        _moduleList = other._moduleList;
        _theErrorDef = other._theErrorDef;
        _prfs = other._prfs;

        if(_fit_type == 0)
          trackFitter = TrackFitterFactory::getTrackFitter( 
              TrackFitterBase::FitterTypes::LINEARREGRESSION,0);
        else if(_fit_type == 1)
          trackFitter = TrackFitterFactory::getTrackFitter( 
              TrackFitterBase::FitterTypes::SIMPLEHELIXFIT,0);
      }

      MMRefitTool &operator=( const MMRefitTool& other )
      {
        _fit_type = other._fit_type;
        _nPar = other._nPar;
        _prfType = other._prfType;
        _rowDep = other._rowDep;
        _moduleDep = other._moduleDep;
        _seedTrack = other._seedTrack;
        _fitTrack = other._fitTrack;
        _normType = other._normType;
        _padHits = other._padHits;
        _moduleList = other._moduleList;
        _theErrorDef = other._theErrorDef;
        _prfs = other._prfs;
        if(_fit_type == 0)
          trackFitter = TrackFitterFactory::getTrackFitter( 
              TrackFitterBase::FitterTypes::LINEARREGRESSION,0);
        else if(_fit_type == 1)
          trackFitter = TrackFitterFactory::getTrackFitter( 
              TrackFitterBase::FitterTypes::SIMPLEHELIXFIT,0);
        return *this;
      }

                        void setModules(const std::vector<int>& modules)
                        {
                                _moduleDep = true;

                                for(unsigned int i = 0; i < modules.size(); i++)
                                        _moduleList[modules[i]] = i;
                        };

                        // Required functions from inheritance.
                        virtual double Up() const{
                                return _theErrorDef;
                        };

                        double operator()(const std::vector<double>& x) const {
                                double * xx = new double[x.size()];
                                for(unsigned int i = 0; i < x.size(); i++)  xx[i] = x[i];
                                return (*this)(xx);     
                        };

                        //The main chi2 function
                        double operator()(const double* x) const ;   

                        void SetErrorDef(double def){
                                _theErrorDef = def;
                        };

                        std::vector<double> retrievePar(const double* x);
                        std::vector<double> retrieveChi2(const double* x);

                private:

                        int _fit_type;
                        int _nPar;
                        std::string _prfType;
                        bool _rowDep;
                        bool _moduleDep;
                        const IMPL::TrackImpl * _seedTrack;
                        bool _fitTrack;
                        int _normType;
                        bool _padHits;

                        std::map<int, int>  _moduleList;

                        double                                  _theErrorDef;
                        TrackFitterBase * trackFitter;  

                        //Vector containing pre-built PRF objects for easy access
                        std::vector<MMPadResponseFunction> _prfs;

                        void padData(const EVENT::TrackerPulse * , const EVENT::LCObjectVec& , std::vector< std::pair <double, float> >& ) const;
                        double calcRowDep(const double * x, int index, int row) const;

        };//End MMRefitTool class

}//End namespace marlintpc

#endif