FullLDCTracking_MarlinTrk.h

#ifndef FULLLDCTRACKING_H
#define FULLLDCTRACKING_H 1

#include "marlin/Processor.h"
#include <marlin/Global.h>
#include "lcio.h"
#include <string>
#include "ClusterExtended.h"
#include "TrackExtended.h"
#include "TrackerHitExtended.h"
#include "TrackHitPair.h"
#include "HelixClass.h"
#include "ClusterShapes.h"
#include "GroupTracks.h"
//#include "../../BrahmsTracking/include/MarlinTrackFit.h"
#include <map>
#include <set>

#include "MarlinTrk/IMarlinTrack.h"

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

using namespace lcio ;
using namespace marlin ;

//class gear::GearMgr ;

namespace MarlinTrk {
  class HelixFit;
  class IMarlinTrkSystem ;
}


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

  TrackExtended * CombineTracks(TrackExtended * tpcTrk, TrackExtended * siTrk, float maxAllowedOutliers ,bool testCombinationOnly );

//  TrackExtended * TrialCombineTracks(TrackExtended * tpcTrk, TrackExtended * siTrk);

  void Sorting(TrackExtendedVec & trackVec);
  void SelectCombinedTracks();
  void AddNotCombinedTracks();
  void CheckTracks();
  void AddNotAssignedHits();
  void RemoveSplitTracks();
  void AddTrackColToEvt(LCEvent * evt, TrackExtendedVec & trkVec, 
                        std::string TrkColName);
  float CompareTrk(TrackExtended * first, TrackExtended * second, 
                   float d0Cut, float z0Cut, int iopt);
  
  float CompareTrkII(TrackExtended * first, TrackExtended * second, 
                     float d0Cut, float z0Cut, int iopt, float &Angle);
  float CompareTrkIII(TrackExtended * first, TrackExtended * second, 
                      float d0Cut, float z0Cut, int iopt, float &Angle);
  
  void SortingTrackHitPairs(TrackHitPairVec & trackHitPairVec);
  
  void AssignSiHitsToTracks(TrackerHitExtendedVec hitVec,
                            float dcut);
  
  void AssignTPCHitsToTracks(TrackerHitExtendedVec hitVec,
                             float dcut);
  
  void AssignOuterHitsToTracks(TrackerHitExtendedVec hitVec, float dcut, int refit);
  
  void CreateExtrapolations();
  
  void CleanUpExtrapolations();
  
  HelixClass * GetExtrapolationHelix(TrackExtended * track);
  
  void PrintOutMerging(TrackExtended * firstTrackExt, TrackExtended * secondTrackExt, 
                       int iopt);
  
  void GeneralSorting(int * index, float * val, int direct, int nVal);
  
  int SegmentRadialOverlap(TrackExtended* pTracki, TrackExtended* pTrackj);
  bool VetoMerge(TrackExtended* firstTrackExt, TrackExtended* secondTrackExt);
   
  int _nRun ;
  int _nEvt ;
  
  MarlinTrk::HelixFit* _fastfitter;
  
  MarlinTrk::IMarlinTrkSystem* _trksystem ;
  std::string _trkSystemName ;
  
  bool _MSOn, _ElossOn, _SmoothOn ;
  
  std::string _TPCTrackCollection;
  std::string _SiTrackCollection;
  std::string _TPCTrackMCPCollName;
  std::string _SiTrackMCPCollName;
  
  std::string _VTXTrackerHitCollection;
  std::string _SITTrackerHitCollection;
  std::string _SETTrackerHitCollection;
  std::string _FTDPixelHitCollection;
  std::string _FTDSpacePointCollection;
  std::string _TPCTrackerHitCollection;
  std::string _ETDTrackerHitCollection;
  
  std::string _LDCTrackCollection;
  
  
  TrackExtendedVec _allSiTracks;
  TrackExtendedVec _allTPCTracks;
  TrackExtendedVec _allCombinedTracks;
  TrackExtendedVec _allNonCombinedTPCTracks;
  TrackExtendedVec _allNonCombinedSiTracks;
  TrackExtendedVec _trkImplVec;
  TrackerHitExtendedVec _allTPCHits;
  TrackerHitExtendedVec _allVTXHits;
  TrackerHitExtendedVec _allFTDHits;
  TrackerHitExtendedVec _allSITHits;
  TrackerHitExtendedVec _allSETHits;
  TrackerHitExtendedVec _allETDHits;
  
  float PI, PIOVER2, TWOPI;
  
  float _bField;
  float _chi2PrefitCut;
  float _chi2FitCut;
  
  int _debug;
  
  float _dPCutForMerging;
  float _d0CutForMerging;
  float _z0CutForMerging;
  float _dOmegaForMerging;
  float _angleForMerging;
  
  
  int   _forceMerging;
  float _dPCutForForcedMerging;
  float _d0CutForForcedMerging;
  float _z0CutForForcedMerging;
  float _dOmegaForForcedMerging;
  float _angleForForcedMerging;
  
  
  int _mergeTPCSegments;
  float _dPCutToMergeTPC;
  float _PtCutToMergeTPC;
  float _d0CutToMergeTPC;
  float _z0CutToMergeTPC;
  
  float _cosThetaCutHighPtMerge;
  float _cosThetaCutSoftHighPtMerge;
  float _momDiffCutHighPtMerge;
  float _momDiffCutSoftHighPtMerge;
  float _hitDistanceCutHighPtMerge;
  float _maxHitDistanceCutHighPtMerge;
  float _maxFractionOfOutliersCutHighPtMerge;
  
  float _vetoMergeMomentumCut;
  
  float _initialTrackError_d0;
  float _initialTrackError_phi0;
  float _initialTrackError_omega;
  float _initialTrackError_z0;
  float _initialTrackError_tanL;
  
  double _maxChi2PerHit;
  double _minChi2ProbForSiliconTracks;
  float  _maxAllowedPercentageOfOutliersForTrackCombination;
  int    _maxAllowedSiHitRejectionsForTrackCombination;
  
  bool _runMarlinTrkDiagnostics;
  std::string _MarlinTrkDiagnosticsName;
  
  int _nHitsExtrapolation;
  
  int _cutOnTPCHits;
  int _cutOnSiHits;
  
  
  int _assignVTXHits,_assignFTDHits,_assignSITHits,_assignTPCHits;
  
  int _assignSETHits, _assignETDHits;
  
  float _distCutForVTXHits,_distCutForFTDHits,_distCutForSITHits,_distCutForTPCHits;
  
  float _distCutForSETHits, _distCutForETDHits;
  
  
  float _d0TrkCut,_z0TrkCut;
  
  int _forbidOverlapInZTPC,_forbidOverlapInZComb;

  float _energyLossErrorTPC;
  
  LCEvent * _evt;
  
  std::map<TrackExtended*,HelixClass*> _trackExtrapolatedHelix;
  std::set<TrackExtended*> _candidateCombinedTracks;
  
  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]; };

  
  void setupGearGeom( const gear::GearMgr* gearMgr ) ;
  
  double _tpc_inner_r;
  double _tpc_outer_r;
  double _tpc_pad_height;
  int    _tpc_nrows;
  
//  struct VXD_Layer {
//    int nLadders;
//    double phi0;
//    double dphi;
//    double senRMin;
//    double supRMin;
//    double length;
//    double width;
//    double offset;
//    double senThickness;
//    double supThickness;
//  };
//  std::vector<VXD_Layer> _VXDgeo;
  
  unsigned int _nLayersVTX;
  
//  struct SIT_Layer {
//    int nLadders;
//    double phi0;
//    double dphi;
//    double senRMin;
//    double supRMin;
//    double length;
//    double width;
//    double offset;
//    double senThickness;
//    double supThickness;
//  };
//  std::vector<SIT_Layer> _SITgeo;
  
  unsigned int _nLayersSIT;
  
  unsigned int _nLayersSET;

  
//  struct FTD_Disk {
//    int nPetals;
//    double phi0;
//    double dphi;
//    
//    double alpha;
//    double rInner;
//    double height;
//    double innerBaseLength;
//    double outerBaseLength;
//    double senThickness;
//    double supThickness;
//    
//    double senZPos_even_petal1;
//    double senZPos_even_petal2;
//    double senZPos_even_petal3;
//    double senZPos_even_petal4;
//    
//    double supZPos_even_petal1;
//    double supZPos_even_petal2;
//    double supZPos_even_petal3;
//    double supZPos_even_petal4;
//    
//    double senZPos_odd_petal1;
//    double senZPos_odd_petal2;
//    double senZPos_odd_petal3;
//    double senZPos_odd_petal4;
//    
//    double supZPos_odd_petal1;
//    double supZPos_odd_petal2;
//    double supZPos_odd_petal3;
//    double supZPos_odd_petal4;
//    
//    
//    
//  };
//  
//  std::vector<FTD_Disk> _FTDgeo;
  std::vector<float> _zLayerFTD;
  
  unsigned int _nLayersFTD;
  int _nPhiFTD; 
  bool  _petalBasedFTDWithOverlaps;
  
} ;

#endif