ForwardTracking.h

#ifndef ForwardTracking_h
#define ForwardTracking_h 1

#include <string>

#include "marlin/Processor.h"
#include "lcio.h"
#include "EVENT/TrackerHit.h"
#include "EVENT/Track.h"
#include "IMPL/TrackImpl.h"
#include "MarlinTrk/IMarlinTrkSystem.h"
#include "gear/BField.h"

#include "KiTrack/Segment.h"
#include "KiTrack/ITrack.h"
#include "Criteria/Criteria.h"
#include "ILDImpl/SectorSystemFTD.h"

using namespace lcio ;
using namespace marlin ;
using namespace KiTrack;
using namespace KiTrackMarlin;

typedef std::vector< IHit* > RawTrack;


class ForwardTracking : public Processor {
  
 public:
  
  virtual Processor*  newProcessor() { return new ForwardTracking ; }
  
  
  ForwardTracking() ;
  
  virtual void init() ;
  
  virtual void processRunHeader( LCRunHeader* run ) ;
  
  virtual void processEvent( LCEvent * evt ) ; 
  
  
  virtual void check( LCEvent * evt ) ; 
  
  
  virtual void end() ;
  

  
  
 protected:
   
   std::map< IHit* , std::vector< IHit* > > getOverlapConnectionMap( const std::map< int , std::vector< IHit* > > & map_sector_hits, 
                                                                     const SectorSystemFTD* secSysFTD,
                                                                     float distMax);
   
   std::vector < RawTrack > getRawTracksPlusOverlappingHits( RawTrack rawTrack , std::map< IHit* , std::vector< IHit* > >& map_hitFront_hitsBack );
   
   void finaliseTrack( TrackImpl* trackImpl );
   
   bool setCriteria( unsigned round );
   
   
   std::string getInfo_map_sector_hits();
   
   
   std::vector<std::string> _FTDHitCollections;
   
   std::string _ForwardTrackCollection;


   int _nRun ;
   int _nEvt ;

   double _Bz;

   double _chi2ProbCut; 
   
   double _helixFitMax; 

   // Properties of the Kalman Fit
   bool _MSOn ;
   bool _ElossOn ;
   bool _SmoothOn ;
   
   int _maxHitsPerSector;
   
   
   // Properties for the Hopfield Neural Network
   double _HNN_Omega;
   double _HNN_ActivationThreshold;
   double _HNN_TInf;
   
   std::map< int , std::vector< IHit* > > _map_sector_hits;
   
   std::vector< std::string > _criteriaNames;
   
   std::map< std::string , std::vector<float> > _critMinima;
   
   std::map< std::string , std::vector<float> > _critMaxima;
   
   int _hitsPerTrackMin;
   
   std::vector <ICriterion*> _crit2Vec;
   
   std::vector <ICriterion*> _crit3Vec;
   
   std::vector <ICriterion*> _crit4Vec;
   
   
   const SectorSystemFTD* _sectorSystemFTD;
   
   
   bool _useCED;
   
   double _overlappingHitsDistMax;
   
   bool _takeBestVersionOfTrack;
   
   int _maxConnectionsAutomaton;
   
   std::string _bestSubsetFinder;
   
   unsigned _nTrackCandidates;
   unsigned _nTrackCandidatesPlus;

   
   
   MarlinTrk::IMarlinTrkSystem* _trkSystem;

   std::string _trkSystemName ;

  bool _getTrackStateAtCaloFace ;

   int _output_track_col_quality ; 
  
   static const int _output_track_col_quality_GOOD;
   static const int _output_track_col_quality_FAIR;
   static const int _output_track_col_quality_POOR;
  
   
} ;


class TrackCompatibilityShare1SP{
  
public:
   
   inline bool operator()( ITrack* trackA, ITrack* trackB ){
      
      
      std::vector< IHit* > hitsA = trackA->getHits();
      std::vector< IHit* > hitsB = trackB->getHits();
      
      
      for( unsigned i=0; i < hitsA.size(); i++){
         
         for( unsigned j=0; j < hitsB.size(); j++){
            
            if ( hitsA[i] == hitsB[j] ) return false;      // a hit is shared -> incompatible
            
         }
         
      }
      
      return true;      
      
   }
   
};


class TrackQIChi2Prob{
   
public:
   
   inline double operator()( ITrack* track ){ return track->getChi2Prob(); }
  
   
};

class TrackQIChi2ProbSpecial{
   
public:
   
   inline double operator()( ITrack* track ){ 
      
      if( track->getHits().size() > 3 ){
         
         return track->getChi2Prob()/2. +0.5; 
         
      }
      else{
         
         return track->getChi2Prob()/2.;
         
      }
      
   }
   
   
};


#endif