TrackingFeedbackProcessor.h

#ifndef TrackingFeedbackProcessor_h
#define TrackingFeedbackProcessor_h 1

#include <string>

#include "marlin/Processor.h"
#include "lcio.h"
#include "EVENT/LCCollection.h"
#include "EVENT/MCParticle.h"
#include "EVENT/LCRelation.h"
#include "EVENT/Track.h"

#include "TROOT.h"
#include "TTree.h"
#include "TFile.h"

#include "TrueTrack.h"
#include "RecoTrack.h"



using namespace lcio ;
using namespace marlin ;


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

   
   double _Bz; //B field in z direction
   
   
   std::string _colNameMCTrueTracksRel;
   std::string _TrackCollection;

   
   std::string _tableFileName;


   int _nRun ;
   int _nEvt ;
   
   double _cutPtMin;
   double _cutDistToIPMax;
   double _cutChi2Prob;
   int    _cutNHitsMin;
   bool _cutNHitsMin_HitsCountOncePerLayer;
   double _cutThetaMin;
   double _cutThetaMax;
   bool _cutFitFails;

   
   bool _MSOn ;
   bool _ElossOn ;
   bool _SmoothOn ;
   
   
   
   unsigned _nComplete;            // complete tracks without extra points
   unsigned _nCompletePlus;        // complete tracks with extra points
   unsigned _nLost;                // lost tracks = tracks that do exist in reality (mcp), but are not represented in the tracksearch results  
   unsigned _nIncomplete;          // incomplete tracks without extra points. i.e.: tracks that are too short (for example 1 or 2 hits are still missing)
   unsigned _nIncompletePlus;      // incomplete tracks with extra points. the reconstructed track belongs to the true track that hold more than half of the points of the track
   unsigned _nGhost;               // ghost tracks = tracks that are reconstructed, but don't actually exist. Pure fiction. a ghost track 
                                   // is a track, where no real track owns more than half of the tracks hits.
   unsigned _nFoundCompletely;     // tracks have been found that contain all the hits of this track
   unsigned _nRecoTracks;          // the number of reconstructed tracks, that were compared to the true tracks
   unsigned _nDismissedTrueTracks; // number of the true tracks, that haven't been used
   unsigned _nValidTrueTracks;     // number of valid true tracks, i.e. true tracks not failing the cuts
   unsigned _nClones;              // the number of tracks that are reconstructed although there already is a reconstruction
                                   // --> The number of clones for a true track is nReco - 1, or 0 if there are no reco tracks
   
   unsigned _nComplete_Sum;            
   unsigned _nCompletePlus_Sum;       
   unsigned _nLost_Sum;               
   unsigned _nIncomplete_Sum;         
   unsigned _nIncompletePlus_Sum;   
   unsigned _nGhost_Sum;            
   unsigned _nFoundCompletely_Sum;     
   unsigned _nRecoTracks_Sum;          
   unsigned _nDismissedTrueTracks_Sum; 
   unsigned _nValidTrueTracks_Sum;
   unsigned _nClones_Sum;
   
   
   std::vector< TrueTrack* > _trueTracks;
   std::vector< RecoTrack* > _recoTracks;
   
   bool _drawMCPTracks;
   bool _saveAllEventsSummary;
   std::string _summaryFileName;
  
   
  
   
   void checkTheTrack( RecoTrack* recoTrack );
   TrueTrack* getAssignedTrueTrack( std::vector<TrueTrack*> relatedTrueTracks , unsigned& nHitsFromAssignedTrueTrack );
   
   unsigned getNumberOfHitsFromDifferentLayers( std::vector< TrackerHit* > hits );
   double getDistToIP( MCParticle* mcp );
   
   MarlinTrk::IMarlinTrkSystem* _trkSystem;
   
   TTree * _treeTrueTracks;
   TTree * _treeRecoTracks;
   TFile * _rootFile;
   std::string _rootFileName;
   bool _rootFileAppend;
   std::string _treeNameTrueTracks;
   std::string _treeNameRecoTracks;
   
   
   void saveRootInformation();   
   void makeRootBranches();
   void setRootBranches();
   

   float _rateOfFoundHitsMin;  //more than this number of hits of the real track must be in the reco track
   float _rateOfAssignedHitsMin;  //more than this number of hits of the reco track must belong to the assigned true track
   
   
   
   int _trueTrack_nComplete;
   int _trueTrack_nCompletePlus;
   int _trueTrack_nIncomplete;
   int _trueTrack_nIncompletePlus;
   int _trueTrack_nSum;
   double _trueTrack_pt;
   double _trueTrack_theta;
   int _trueTrack_nHits;
   double _trueTrack_vertexX;
   double _trueTrack_vertexY;
   double _trueTrack_vertexZ;
   double _trueTrack_chi2prob;
   double _trueTrack_chi2;
   int _trueTrack_Ndf;
   
   int _recoTrack_nTrueTracks;
   double _recoTrack_pt;
   double _recoTrack_chi2prob;
   double _recoTrack_chi2;
   int _recoTrack_Ndf;
   
   
} ;

#endif