SiliconTrackingCLIC.h

#ifndef SILICONTRACKINGCLIC_H
#define SILICONTRACKINGCLIC_H 1

#include "marlin/Processor.h"
#include "lcio.h"
#include <string>
#include <vector>
#include <IMPL/TrackImpl.h>
#include "ClusterExtended.h"
#include "TrackExtended.h"
#include "TrackerHitExtended.h"
#include "HelixClass.h"
#include "../../BrahmsTracking/include/MarlinTrackFit.h"

using namespace lcio ;
using namespace marlin ;


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

  int _nRun ;
  int _nEvt ;

  int _nDivisionsInPhi;
  int _nDivisionsInTheta;
  int _nLayers;

  int _nLayersFTD;
  int _nLayersVTX;
  int _nLayersSIT;
  int _nPhiFTDBase;
  int _maxNumberOfFTDCombinations;
  int _nPhiFTD;

  std::string _VTXHitCollection;
  std::string _FTDHitCollection;
  std::string _SITHitCollection;
  std::string _siTrkCollection;
  std::string _siTrkMCPCollection;
  
  std::vector<TrackerHitExtendedVec> _sectors;
  std::vector<TrackerHitExtendedVec> _sectorsFTD;
  //MB Added vectors for larger combination of Tracks
  TrackExtendedVec _tracks12Hits;
  TrackExtendedVec _tracks11Hits;
  TrackExtendedVec _tracks10Hits;
  TrackExtendedVec _tracks9Hits;
  TrackExtendedVec _tracks8Hits;
  TrackExtendedVec _tracks7Hits; 
  TrackExtendedVec _tracks6Hits;
  TrackExtendedVec _tracks5Hits;
  TrackExtendedVec _tracks4Hits;
  TrackExtendedVec _tracks3Hits;

  int InitialiseVTX(LCEvent * evt);
  int InitialiseFTD(LCEvent * evt);
  void ProcessOneSector(int iSectorPhi, int iSectorTheta);
  void CleanUp();
  TrackExtended * TestTriplet(TrackerHitExtended * outerHit, 
                              TrackerHitExtended * middleHit,
                              TrackerHitExtended * innerHit,
                              HelixClass & helix);
  int BuildTrack(TrackerHitExtended * outerHit, 
                 TrackerHitExtended * middleHit,
                 TrackerHitExtended * innerHit,
                 HelixClass & helix, 
                 int innerlayer,
                 int iPhiLow, int iPhiUp,
                 int iTheta, int iThetaUp,
                 TrackExtended * trackAR);

  void Sorting( TrackExtendedVec & trackVec);
  void CreateTrack(TrackExtended * trackAR );
  void AttachRemainingVTXHitsSlow();
  void AttachRemainingFTDHitsSlow();
  void AttachRemainingVTXHitsFast();
  void AttachRemainingFTDHitsFast();
  void TrackingInFTD();
  int BuildTrackFTD(TrackExtended * trackAR, int * nLR, int iS);
  int AttachHitToTrack(TrackExtended * trackAR, TrackerHitExtended * hit);
  void FinalRefit();

  float _bField;
  float _chi2WRPhiTriplet;
  float _chi2WRPhiQuartet;
  float _chi2WRPhiSeptet;
  float _chi2WZTriplet;
  float _chi2WZQuartet;
  float _chi2WZSeptet;
  float _minDistCutAttach;
  int _minimalLayerToAttach;

  double PI,TWOPI,PIOVER2;
  double _dPhi;
  double _dTheta;
  double _dPhiFTD;

  int _debug;

  std::vector<float> _zLayerFTD;
  std::vector<int> _Combinations;
  std::vector<int> _CombinationsFTD;

  float _resolutionRPhiVTX;
  float _resolutionZVTX;
  
  float _resolutionRPhiFTD;
  float _resolutionZFTD;

  float _resolutionRPhiSIT;
  float _resolutionZSIT;

  float _phiCutForMerging;
  float _tanlambdaCutForMerging;
  float _angleCutForMerging;

  int _print;
  int _checkForDelta;
  float _minDistToDelta;

  float _distRPhi;
  float _distZ;
  float _chi2FitCut;

  float _chi2PrefitCut;

  TrackExtendedVec _trackImplVec;

  float _cutOnD0, _cutOnZ0, _cutOnOmega, _cutOnPt;

  int _minimalHits;
  int _attachFast;

  int _nTotalVTXHits,_nTotalFTDHits,_nTotalSITHits;
  int _optFit,_simpleHelixFit;
  int _useSIT;
  int _finalRefit;
  int _createMap;
  int _useExtraPoint;
  MarlinTrackFit _trackFit;


inline int min(int a,int b) {
  if (a<b) return a;
  return b;
}

inline int max(int a,int b) {
  if (a>b) return a;
  return b;
}

inline int abs(int x) {
  if (x<0) return -x;
  return x;
}


} ;

#endif