TrackSeederProcessor.h

#ifndef TRACKSEEDERPROCESSOR_H
#define TRACKSEEDERPROCESSOR_H 1

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

#include <EVENT/TrackerHit.h>

namespace marlintpc
{

class TrackSeederProcessor : public marlin::Processor
{

    public:

        TrackSeederProcessor();


        ~TrackSeederProcessor();


        Processor * newProcessor();


        void init();


        void processRunHeader(lcio::LCRunHeader *run);


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


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


        virtual void end();

    private:

        std::string _input_track_candidates_collection_name;

        std::string _output_seed_tracks_collection_name;

        int _outputIsTransient;    //< if not 0 the hits collection is set transient (default 0)

        bool _produce_s_z_tuples;

        double _radius_threshold;

        std::string _tpc_conditions_collection_name;

        std::vector<double> calculate_least_squares_line(std::vector< std::pair<double, double> > points);

        std::vector<double> calculate_least_squares_circle(std::vector< std::pair<double, double> > points);


        class sort_by_distance_from_point
        {

            public:
                sort_by_distance_from_point(double x, double y, double z):
                        _x(x),
                        _y(y),
                        _z(z) {};

                bool operator()(EVENT::TrackerHit* hit1, EVENT::TrackerHit* hit2)
                {
                    double dx = _x - hit1->getPosition()[0];
                    double dy = _y - hit1->getPosition()[1];
                    double dz = _z - hit1->getPosition()[2];

                    const double d1 = sqrt(dx * dx + dy * dy + dz * dz);

                    dx = _x - hit2->getPosition()[0];
                    dy = _y - hit2->getPosition()[1];
                    dz = _z - hit2->getPosition()[2];

                    const double d2 = sqrt(dx * dx + dy * dy + dz * dz);

                    return (d1 < d2);
                }
            private:
                // the point the distance is calculated from
                double _x, _y, _z;
        };

        class sort_by_z
        {
            public:
                bool operator()(std::pair<double, double> sz1, std::pair<double, double> sz2)
                {
                    return (sz1.second < sz2.second);
                }
        };

//  /// The pad layout as defined in GEAR
//  gear::PadRowLayout2D const *_padLayout;
//  int _padLayoutType; ///< Pad layout type (PadRowLayout2D::CARTESIAN or PadRowLayout2D::POLAR)

};

}// namespace marlintoc

#endif // TRACKSEEDERPROCESSOR_H