RowTripletBasedTrackFinderProcessor.h

#ifndef ROWTRIPLETBASEDTRACKFINDERPROCESSOR_H
#define ROWTRIPLETBASEDTRACKFINDERPROCESSOR_H

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

#include <gear/TPCModule.h>

// LCIO:
#include "EVENT/TrackerHit.h"

#include "TFile.h"
#include "TTree.h"
#include "TMath.h"
#include "TVectorD.h"
#include "TMatrixD.h"
#include "TMatrixDSym.h"

namespace marlintpc {

class RowTripletBasedTrackFinderProcessor: public marlin::Processor {
        public:

                virtual Processor* newProcessor() {
                        return new RowTripletBasedTrackFinderProcessor;
                }

                RowTripletBasedTrackFinderProcessor();

                virtual void init();

                virtual void processRunHeader(EVENT::LCRunHeader* run);

                virtual void processEvent(EVENT::LCEvent* evt);

                virtual void check(EVENT::LCEvent* evt);

                virtual void end();

        protected:
                /* the place for protected and private member data and functions */
                std::string _inputColName; 
                std::string _outputColName;  
                double _bfieldScaleFactor; 
                double _distCut; 
                double _trpCut; 
                double _posCut; 
                double _dirCut; 
                double _segCut; 
                double _unusedCut; 
                int _maxGap; 
                bool _encodedModuleID; 
                bool _refAtPCA; 

        private:

                double _Bzc; 
                std::map<int, std::vector<int> > _modNeighbours; 
                double _Xcenter; 
                double _Ycenter; 

                bool areNeighbourModules(gear::TPCModule*, gear::TPCModule*, bool);
};


class rb_Hit {
        public:
                rb_Hit(const int iHit, const int mod, const int row, const EVENT::TrackerHit& aHit);
                void print() const;
                int getHitNum() const;
                int getMod() const;
                int getRow() const;
                double getX() const;
                double getY() const;
                double getZ() const;
                void getPos(double*) const;
                double getVarXY(const double = 0.) const;
                double getVarZ(const double = 0.) const;
                double getPhiMeas() const;
                bool getUsed() const;
                void setUsed(const double);
                double getCosBeta() const;
                double getDistXY(const double, const double, const double, const double) const;
                double getDistZ(const double) const;

        private:
                const int _hitNum; 
                const int _hitModule; 
                const int _hitRow; 
                const double _hitX; 
                const double _hitY; 
                const double _hitZ; 
                const double _hitPhiMeas; 
                const double _hitVarXY; 
                const double _hitVarR; 
                const double _hitVarZ; 
                bool _used; 
                double _cosb; 

                double _calcPhiMeas(const EVENT::TrackerHit& aHit);
                double _getVarXY(FloatVec);
                double _getVarR(FloatVec);
                double _getVarZ(FloatVec);

};

typedef std::vector<rb_Hit*> hitListType;
typedef std::map<int, hitListType> rowHitMapType;
typedef std::map<int, rowHitMapType> modHitMapType;


class rb_Doublet {
        public:
                rb_Doublet(rb_Hit*, rb_Hit*);
                bool match(rb_Hit*, const double, const double) const;
                rb_Hit* getHit(const int) const;
                void getParameters(double&, double&, double&, double&, double&, double&, double&, double&, double&, double&) const;

        private:
                rb_Hit* _hit[2]; 
                double _phiMeas; 
                double _cosPhi; 
                double _sinPhi; 
                double _xav; 
                double _yav; 
                double _zav; 
                double _phi; 
                double _tanl; 
                double _length; 
                double _cosb; 
                double _der2XY; 
                double _der2Z; 
                double _varXY; 
                double _varZ; 
};


class rb_Triplet {
        public:
                rb_Triplet(rb_Doublet&, rb_Hit*);
                int getRow() const;
                double getX() const;
                double getY() const;
                double getZ() const;
                void getPos(double*) const;
                double getVarXYPos(const double = 0.) const;
                double getVarXYDir() const;
                double getVarZPos(const double = 0.) const;
                double getVarZDir() const;
                double getPhiMeas() const;
                double getPhi() const;
                double getTanl() const;
                void getPosCloseTo(const double, const double, double*, double&) const;
                rb_Hit* getHit(const int) const;
                bool match(rb_Triplet*, const double, const double) const;
                double getCosBeta() const;

        private:
                rb_Hit* _hit[3]; 
                double _phiMeas; 
                double _posX; 
                double _posY; 
                double _posZ; 
                double _varXY[2]; 
                double _phi; 
                double _tanl; 
                double _varZ[2]; 
                double _length; 
                double _cosb; 
};

typedef std::vector<rb_Triplet*> trpListType;


class rb_Segment {
        public:
                rb_Segment(double, trpListType);
                rb_Segment(double, hitListType, unsigned int = 1);
                rb_Segment(std::vector<rb_Segment*> segments);
                double getBzc() const;
                int getFirstRow() const;
                int getLastRow() const;
                void getRefPoint(double*) const;
                int getNdf() const;
                double getChi2() const;
                void getPar(double *) const;
                const hitListType& getHitList() const;
                const TVectorD& getPar() const;
                const TMatrixDSym& getCov() const;
                bool match(rb_Segment*, const double, const int) const;
                bool match(rb_Hit*, const double) const;
                void match(hitListType&, hitListType&, const double) const;
                void getLCIOStateAtRefPoint(const double*, TVectorD&, TMatrixDSym&) const;
                void fillRowMap(std::map<int, int>&) const;
                int getId() const;
                void setId(int);
                void addHit(rb_Hit *);

        private:
                int _segId; 
                hitListType _hitList; 
                double _bzc; 
                double _refX; 
                double _refY; 
                double _refZ; 
                int _npar; 
                int _ndf; 
                double _chi2; 
                TVectorD _parameters; 
                TMatrixDSym _covariance; 
                void calcRefPoint();
                void fitSegment(double);
};

typedef std::vector<rb_Segment*> segListType;
typedef std::map<int, segListType> modSegMapType;


class simpleEquiClasses {
        public:
                simpleEquiClasses();
                void addIndex(int);
                void addMatch(std::pair<int, int>);
                std::map<int, std::vector<int> > getClasses();

        private:
                std::map<int, int> _index; 
                std::vector<std::pair<int, int> > _matches;  
};

} // namespace marlintpc
#endif // ROWTRIPLETBASEDTRACKFINDERPROCESSOR_H