TrackFitterLikelihoodProcessor.h

#ifndef TRACKFITTERLIKELIHOODPROCESSOR_H
#define TRACKFITTERLIKELIHOODPROCESSOR_H 1

#include "marlin/Processor.h"

#include "TrackFitterBase.h"

#include "TPCConditionsListener.h"

// LCIO
#include "lcio.h"

/* NOTE this uses the C++ version of Minuit - not the Fortran version */
#include "Minuit2/FCNBase.h"

// stl
#include <string>
#include <vector>

// some forward declarations

namespace AIDA
{

class ITuple;
}

namespace EVENT
{
class LCEvent;
class LCRunHeader;
class Track;
}

namespace IMPL
{

class TrackImpl;
class TrackerHitImpl;
}

namespace marlintpc
{

class TrackFitterLikelihoodProcessor : public marlin::Processor, public ROOT::Minuit2::FCNBase
{

    public:

        TrackFitterLikelihoodProcessor();


        ~TrackFitterLikelihoodProcessor();


        marlin::Processor * newProcessor();


        void init();


        void processRunHeader(lcio::LCRunHeader *run);


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


        // From FCNBase
        virtual double operator()(const std::vector<double>& x) const;

        virtual double Up() const;


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


        virtual void end();


    private:

        void calculate_expected_charge_distribution(TrackImpl &expected_track, double sigma0) const;

        void calculate_expected_charge_distribution_homogeneous_polar(IMPL::TrackImpl&, const double) const;

        void calculate_expected_charge_distribution_homogeneous_cartesian(IMPL::TrackImpl&, const double) const;

        void calculate_expected_charge_distribution_non_homogeneous_polar(IMPL::TrackImpl&, const double) const;

        void calculate_expected_charge_distribution_non_homogeneous_cartesian(IMPL::TrackImpl&, const double) const;

        void calculate_expected_charge_distribution_polar_row(IMPL::TrackerHitImpl&, const EVENT::TrackerHit &data_hit, const double, const double, const double) const;

        void calculate_expected_charge_distribution_cartesian_row(IMPL::TrackerHitImpl&, const EVENT::TrackerHit &data_hit, const double, const double, const double) const;

        const double calculate_charge_distribution_log_likelihood(const EVENT::Track&) const;


        const double calculate_primary_ionization_location_log_likelihood(const Track&) const;


        IMPL::TrackImpl find_most_likely_fit(EVENT::Track* seed_track);


        double calculate_expected_distribution(double b, double phi, double sigma,
                                               double height, double width) const;

        std::string _seed_track_collection_name;

        std::string _fitted_track_collection_name;

        std::string _tpc_conditions_collection_name;

        double _sigma0;

        bool _fit_sigma0;

        double _gas_trans_diffusion_constant;

        double _gas_trans_defocussing_constant;

        double _p_noise;

        EVENT::Track* _current_seed_track;

        double _readout_electronics_inner_z;

        double _sigma_z;

        bool _produce_tuples;

        AIDA::ITuple *_track_result_tuples;

        double _omega_tau;

        double _drift_velocity;

        double _path_integral_step_size;

        double _tpc_outer_radius;

        bool _fit_nonhomogeneous_fields;

        int _omega_order_of_magnitude;
        int _tanLambda_order_of_magnitude;

        TPCConditionsListener* _tpcConditionsListener;

        /*class PolarPDF {

            public:
                PolarPDF (const Track &estimated_track);

                double evaluate_pdf_integral( const double r, const double phi );

            private:
                const double _estimated_omega;
                const double _estimated_phi0;
                const double _estimated_d0;
        }*/
};

} // namespace marlintpc

#endif // TRACKFITTERLIKELIHOODPROCESSOR_H