FullLDCTracking.h

#ifndef FULLLDCTRACKING_H
#define FULLLDCTRACKING_H 1

#include "marlin/Processor.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>

using namespace lcio ;
using namespace marlin ;

class FullLDCTracking : public Processor {
  
 public:
  
  virtual Processor*  newProcessor() { return new FullLDCTracking ; }  
  FullLDCTracking() ;  
  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);
  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, std::string RelColName);
  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 ;

  std::string _TPCTrackCollection;
  std::string _SiTrackCollection;
  std::string _TPCTrackMCPCollName;
  std::string _SiTrackMCPCollName;

  std::string _VTXTrackerHitCollection;
  std::string _SITTrackerHitCollection;
  std::string _SETTrackerHitCollection;
  std::string _FTDTrackerHitCollection;
  std::string _TPCTrackerHitCollection;
  std::string _ETDTrackerHitCollection;

  std::string _LDCTrackCollection;
  std::string _LDCTrackMCPCollection;

  std::string _RefittedTPCTrackCollection;
  std::string _RefittedTPCTrackMCPCollection;
  std::string _RefittedSiTrackCollection;
  std::string _RefittedSiTrackMCPCollection;

  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 _resolutionRPhi_TPC,_resolutionZ_TPC;
  float _resolutionRPhi_VTX,_resolutionZ_VTX;
  float _resolutionRPhi_FTD,_resolutionZ_FTD;
  float _resolutionRPhi_SIT,_resolutionZ_SIT;
  float PI, PIOVER2, TWOPI;

  float _bField;
  float _chi2PrefitCut;
  float _chi2FitCut;

  int _debug;
  int _createMap;
  int _useExtraPoint,_optFit;

  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;

  MarlinTrackFit _trackFit;

  int _refitTPCTracks;
  int _refitSiTracks;
  int _storeRefittedTPCTracks;
  int _storeRefittedSiTracks;
  int _storeHitsInFit;

  int _nHitsExtrapolation;

  int _cutOnTPCHits;
  int _cutOnSiHits;

  float _aParIpReso,_bParIpReso,_sParIpReso;

  int _assignVTXHits,_assignFTDHits,_assignSITHits,_assignTPCHits;

  int _assignSETHits, _assignETDHits;

  float _distCutForVTXHits,_distCutForFTDHits,_distCutForSITHits,_distCutForTPCHits;

  float _distCutForSETHits, _distCutForETDHits;

  int _optFitTPC,_optFitSi;

  float _d0TrkCut,_z0TrkCut;

  int _forbidOverlapInZTPC,_forbidOverlapInZComb;

  LCEvent * _evt;

  std::map<TrackExtended*,HelixClass*> _trackExtrapolatedHelix;
  std::set<TrackExtended*> _candidateCombinedTracks;

} ;

#endif