TrackFinderHoughTrafoProcessor.h

#ifndef TrackFinderHoughTrafoProcessor_h
#define TrackFinderHoughTrafoProcessor_h 1

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

// LCIO
#include "lcio.h"

// Marlin
#include "marlin/Processor.h"
#include "lccd/ConditionsMap.hh"

namespace AIDA
{

class IHistogram1D;
class IHistogram2D;


}

namespace marlintpc
{

/* the following comment is tranfered to doxygen documentation
 * which begins with a second asterix, or in case of on line comment an extra third slash
 */
class TrackFinderHoughTrafoProcessor : public marlin::Processor
{

    public:

        /* This method will be called by the marlin package
         * It returns a processor of the currend type (here TrackFinderHoughTrafoProcessor)
         */
        virtual Processor*  newProcessor()
        {
            return new TrackFinderHoughTrafoProcessor ;
        }

        /* the default constructor
         * here the processor parameters are registered to the marlin package
         * other initialisation should be placed in the init method
         */
        TrackFinderHoughTrafoProcessor() ;

        /* Called at the beginning of the job before anything is read.
         * Use to initialize the processor, e.g. book histograms
         */
        virtual void init() ;

        /* Called for every run.
         * in this processor it is not used
         */
        virtual void processRunHeader(lcio::LCRunHeader* run) ;

        /* Called for every event - the working horse.
         * Here the real conversion take place
         */
        virtual void processEvent(lcio::LCEvent * evt) ;

        /* This method is only called if the check flag is set (default) in the main processor
         * (where the input files are given)
         * It should be used to create check plots which are not needed in a complete analysis
         * (where normaly the check flag is deactivated)
         */
        virtual void check(lcio::LCEvent * evt) ;


        /* Called after data processing for clean up.
         * e.g. saving control histogramms, delete created objects
         * (which are not stored in a collection/event), etc.
         */
        virtual void end() ;



        virtual double distanceToTrackFinder(const double *pos,
                                             DoubleVec par,
                                             std::string _trackType);
        struct TrackProperties
        {

            double a; 
            double b; 
            int hitsontrack; 
            int orientation; 

            TrackProperties(double avalue = 0, double bvalue = 0,
                            int hitsontrackvalue = 0, int orientationvalue = 0)
            {

                a = avalue;
                b = bvalue;
                hitsontrack = hitsontrackvalue;
                orientation = orientationvalue;

            };

            bool operator<(TrackProperties const trackproperties) const
            {
                return (hitsontrack < trackproperties.hitsontrack);
            }

            bool operator>(TrackProperties const trackproperties) const
            {
                return (hitsontrack > trackproperties.hitsontrack);
            }

            bool operator==(TrackProperties const trackproperties) const
            {
                return(a == trackproperties.a &&
                       b == trackproperties.b &&
                       hitsontrack == trackproperties.hitsontrack);
            }




        };

        static bool sortPredicate(const TrackProperties& lhs, const TrackProperties& rhs)
        {

            return lhs.hitsontrack > rhs.hitsontrack;

        }

        virtual TrackProperties maxBinFinder(AIDA::IHistogram2D * histo);

        typedef std::vector<TrackProperties> TPVec;



    protected:

        /* normally the doxygen documentation is palced before the method/variable
         * but for one line comments in case of variables it may be more convenied for you
         * to place it after the variable. In this case you use an arrow to tell doxygen
         * to which variable the commet belongs to.
         */

        std::string _inputColName ;  
        std::string _outputColName ; 
        std::string _trackType; 
//  double _pitch; ///<- the pitch of the chip in mm
        double _maxDistanceToTrack; 
        int _nHitsOnTrack; 
        int _chipID; 

        int _outputIsTransient;

        int _nRun ; 

        double a; 
        double b; 

        int _houghSpaceNBinsA; 
        int _houghSpaceNBinsB; 
        float _houghSpaceMaxA; 
        float _houghSpaceMaxB; 

    private:
        AIDA::IHistogram1D * histod;
        AIDA::IHistogram2D * HistoEvent;
        std::vector<AIDA::IHistogram2D *> HistoLineVec;
        std::vector<AIDA::IHistogram2D *> HistoTrackVec;
        std::vector<AIDA::IHistogram2D *> HistoHoughVec;


} ;

}

#endif