TimePixHoughTransformNormalProcessor.h

#ifndef TIMEPIXHOUGHTRANSFORMIMPROCESSOR_H
#define TIMEPIXHOUGHTRANSFORMIMPROCESSOR_H

#include <marlin/Processor.h>
#include <lcio.h>

// CPP
#include <string>
#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>

// ROOT
#include "TH2D.h"
#include "TFile.h"

// LCIO
#include <gear/PadRowLayout2D.h>
#include <EVENT/LCEvent.h>
#include <IMPL/LCCollectionVec.h>
#include <IMPL/TrackImpl.h>
#include <IMPL/LCFlagImpl.h>
#include <EVENT/TrackerHit.h>
#include <Exceptions.h>

#include "TrackFitterFactory.h"
#include "TrackFitterBase.h"

using namespace lcio;
using namespace marlin;
using namespace std;


namespace marlintpc
{
class TimePixHoughTransformNormalProcessor : public marlin::Processor
{
 public:
  
  virtual Processor*  newProcessor() { return new TimePixHoughTransformNormalProcessor; }
  
  TimePixHoughTransformNormalProcessor();
  
  virtual void init();
  
  virtual void processRunHeader(lcio::LCRunHeader* run);
  
  virtual void processEvent(lcio::LCEvent* evt);
  
  virtual void check(lcio::LCEvent* evt);
  
  virtual void end();
  
  /* typedefs */
  typedef std::vector< TrackImpl * > TrackImplVec;

  /* my functions */
  virtual void FillHistogram();
  virtual void GetTrackProperties();
  virtual void CreateTracks();
  virtual void AddHits();
  virtual void RemoveSparseTracks( TrackImplVec & ImplVec, TrackImplVec::iterator itFirst, TrackImplVec::iterator itLast );
  virtual void OutputAddElement( LCCollectionVec *& outputCol, TrackImplVec::iterator itFirst, TrackImplVec::iterator itLast );

  struct TrackProperties
    {
        double _Phi; 
        double _D0; 
        int _hitsontrack; 

        TrackProperties( double phivalue = 0, double d0value = 0
                        , int hitsontrackvalue = 0)
        {
            _Phi = phivalue;
            _D0 = d0value;
            _hitsontrack = hitsontrackvalue;
        };

        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(     _D0 == trackproperties._D0
                    &&   _Phi == trackproperties._Phi
                    &&   _hitsontrack == trackproperties._hitsontrack
                    );
        }
    };

  static bool sortPredicate(const TrackProperties& lhs, const TrackProperties& rhs)
  {
      // locate largest as first element
      return lhs._hitsontrack > rhs._hitsontrack;
  }

  static bool sortTrackImpl( const TrackImpl * lhs, const TrackImpl * rhs )
  {
      // locate largest as first element
      return lhs->getTrackerHits().size() > rhs->getTrackerHits().size();
  }

 protected:
  TH1D * _hMaxConvoluted;

  /* the place for protected and private member data and functions */
  std::string _inputColName;  
  std::string _outputColName; 

  LCCollectionVec * _inputColVec;

  /* parameters: Track */
  int _nHitsOnTrack;            
  int _ChipID;                  
  double _maxDistanceToTrackY;   
  TrackerHitVec _hitVec;         

  /* containers */
  std::vector< TrackProperties > _trackPropertiesY; 
  TrackImplVec _trackImplsY; 

  TH2D * _histoHoughSpace; 
  std::vector< TH2D * > _histoHoughSpaceVec; 

  /* parameters: Hough space XY*/
  int   _houghSpaceNBinsPhi; 
  float _houghSpaceMaxPhi;   
  float _houghSpaceMinPhi;   
  int   _houghSpaceNBinsD0;  
  float _houghSpaceMaxD0;   

  /*  */
  std::string _fileName; 
  int _MaxHisto; 
  int _CurrentHisto; 

  int _outputIsTransient;

};
} // namespace marlintpc
#endif // HOUGHTRAFOIMPROCESSOR_H