TruthTracker.h

#ifndef TruthTracker_h
#define TruthTracker_h 1

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

#include <EVENT/TrackerHit.h>
#include <EVENT/SimTrackerHit.h>
#include <IMPL/LCCollectionVec.h>

#include <UTIL/BitField64.h>
#include <UTIL/ILDConf.h>

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

namespace IMPL {
  class TrackImpl ;
}

namespace UTIL{
  class LCRelationNavigator ;
}


namespace MarlinTrk{
  class IMarlinTrkSystem ;
}

class TruthTracker : public marlin::Processor {
  
public:
  
  virtual marlin::Processor*  newProcessor() { return new TruthTracker ; }
  
  
  TruthTracker() ;
  
  virtual void init() ;
  
  virtual void processRunHeader( LCRunHeader* run ) ;
  
  virtual void processEvent( LCEvent * evt ) ; 
  
  
  virtual void check( LCEvent * evt ) ; 
  
  
  virtual void end() ;
  
  struct SimTrackerHitSortPredicate {
    bool operator()(std::pair<SimTrackerHit*, TrackerHit* > p1, std::pair<SimTrackerHit*, TrackerHit* > p2) {
      
      SimTrackerHit* simHit1 = p1.first;
      SimTrackerHit* simHit2 = p2.first;
      
      
      if( simHit1->getMCParticle() == simHit2->getMCParticle() ) {
        return simHit1->getTime() < simHit2->getTime() ;
      }
      else { 
        return simHit1->getMCParticle() < simHit2->getMCParticle() ;
      }
    }
  };

    
protected:
  
  
  const LCObjectVec* getSimHits( TrackerHit* trkhit, const FloatVec* weights = NULL);
  
  UTIL::BitField64* _encoder;
  int getDetectorID(TrackerHit* hit) { _encoder->setValue(hit->getCellID0()); return (*_encoder)[lcio::ILDCellID0::subdet]; }
  int getSideID(TrackerHit* hit)     { _encoder->setValue(hit->getCellID0()); return (*_encoder)[lcio::ILDCellID0::side]; };
  int getLayerID(TrackerHit* hit)    { _encoder->setValue(hit->getCellID0()); return (*_encoder)[lcio::ILDCellID0::layer]; };
  int getModuleID(TrackerHit* hit)   { _encoder->setValue(hit->getCellID0()); return (*_encoder)[lcio::ILDCellID0::module]; };
  int getSensorID(TrackerHit* hit)   { _encoder->setValue(hit->getCellID0()); return (*_encoder)[lcio::ILDCellID0::sensor]; };

  
  LCCollection* GetCollection(  LCEvent * evt, std::string colName ) ;
  
  LCRelationNavigator* GetRelations( LCEvent * evt, std::string RelName ) ;
  
  void SetupInputCollections( LCEvent * evt ) ;
  
  void createTrack( MCParticle* mcp, UTIL::BitField64& cellID_encoder, std::vector< std::pair<SimTrackerHit*, TrackerHit* > >& hit_list );
  
  void createTrack_old( MCParticle* mcp, UTIL::BitField64& cellID_encoder, std::vector<TrackerHit*>& hit_list );
  
  void createTrack_iterative( MCParticle* mcp, UTIL::BitField64& cellID_encoder,  std::vector< std::pair<SimTrackerHit*, TrackerHit* > >& hit_list );
  
  void drawEvent();
  
  
  std::string  _colNameMCParticles;
  
  std::vector< std::string > _colNamesTrackerHits;
 
  std::vector< std::string > _colNamesTrackerHitRelations;

  std::vector< LCCollection* > _colTrackerHits;
  std::vector< LCRelationNavigator* > _navTrackerHitRel;
  
  std::string _output_track_col_name ;
  LCCollectionVec* _trackVec;
  
  std::string _output_track_rel_name ;
  LCCollectionVec* _trackRelVec;

  
  std::string _output_track_segments_col_name ;
  LCCollectionVec* _trackSegmentsVec;
  
  std::string _output_track_segment_rel_name ;
  LCCollectionVec* _trackSegmentsRelVec;
  
  int _nMCP;
  
  int _n_run ;
  int _n_evt ;
  
  float _MCpThreshold ;

  bool _useMCParticleParametersFotInitOfFit;
  
  MarlinTrk::IMarlinTrkSystem* _trksystem ;
  bool _runMarlinTrkDiagnostics;
  std::string _MarlinTrkDiagnosticsName;

  bool _FitTracksWithMarlinTrk;
  bool _create_prefit_using_MarlinTrk;
    
  bool _MSOn ;
  bool _ElossOn ;
  bool _SmoothOn ;

  float _initialTrackError_d0;
  float _initialTrackError_phi0;
  float _initialTrackError_omega;
  float _initialTrackError_z0;
  float _initialTrackError_tanL;

  bool  _UseIterativeFitting;
  bool  _UseEventDisplay;
  
  double _maxChi2PerHit;
    
  double _Bz;

  unsigned _nCreatedTracks;
  
  EVENT::LCEvent* _current_event;
  
  int _detector_model_for_drawing;
  std::vector<int> _colours;  
  float     _helix_max_r;
  
  std::string _trkSystemName ;

  int _fitDirection ;
} ;

#endif