TimePixLocalRoadSearchProcessor.h

#ifndef TIMEPIXLOCALROADSEARCHPROCESSOR_H
#define TIMEPIXLOCALROADSEARCHPROCESSOR_H

#include "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 TimePixLocalRoadSearchProcessor: public marlin::Processor {
        public:

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

                TimePixLocalRoadSearchProcessor();

                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; 
                int _minTrackLevel; 
                int _mpSize; 
                double _minZmeas; 
                double _maxZmeas; 
                double _sigmaZ; 
                double _xOffset; 
                double _yOffset; 
                int _maxMult; 
                int _minPixels; 
                int _minDist; 
                double _maxPull2XY; 
                double _maxPull2Z; 
                double _maxChi2; 
                double _maxSvar; 
                double _maxGap; 
                int _octoOffset; 
                int _octoScale; 
                double _chi2CutChip; 
                double _chi2CutOcto; 
                double _chi2CutMod; 
                double _distCut; 
                bool _refAtPCA; 

        private:
                double _Bzc; 
                double _Xcenter; 
                double _Ycenter; 
};

class tp_Pixel {
        public:
                tp_Pixel(const int, const EVENT::TrackerHit&, const double, const double);
                void print() const;
                int getHitNum() const;
                int getChip() const;
                int getRow() const;
                int getCol() const;
                double getX() const;
                double getY() const;
                double getZ() const;
                void getPos(double*) const;
                double getSigma2XY() const;
                double getSigma2Z() const;
                double getArcLength() const;
                bool getUsed() const;
                void setUsed();
                void setArcLength(const double);

        private:
                const int _hitNum; 
                const int _chipNum; 
                const int _rowNum; 
                const int _colNum; 
                const double _posX; 
                const double _posY; 
                const double _posZ; 
                const double _sigma2XY; 
                const double _sigma2Z; 
                bool _used; 
                double _sarc; 

};

typedef std::vector<tp_Pixel*> pixelListType;
typedef std::map<int, pixelListType> chipPixelMapType;

class tp_MacroPixel {
        public:
                tp_MacroPixel(const int, pixelListType&, const int);
                ~tp_MacroPixel();
                void print() const;
                int getId() const;
                int getSize() const;
                int getEntries() const;
                int getRow() const;
                int getCol() const;
                double getX() const;
                double getY() const;
                double getZ() const;
                void getPos(double*) const;
                double getVarXY(const double, const double) const;
                double getVarZ() const;
                double getSigma2XY() const;
                double getSigma2Z() const;
                bool getUsed() const;
                void setUsed();
                pixelListType getPixels() const;

        private:
                const int _mpId; 
                const int _size; 
                const int _entries; 
                pixelListType _pixels; 
                bool _used; 
                double _posX; 
                double _posY; 
                double _posZ; 
                double _varXX; 
                double _varXY; 
                double _varYY; 
                double _varZZ; 
                double _sigma2XY; 
                double _sigma2Z; 
                int _locRow; 
                int _locCol; 

};

typedef std::vector<tp_MacroPixel*> macroPixelListType;
typedef std::pair<tp_MacroPixel*, tp_MacroPixel*> macroPixelPairType;
typedef std::vector<macroPixelPairType> macroPixelPairListType;
typedef std::map<int, macroPixelPairListType> macroPixelPairListMapType;

class tp_PixelBin {
        public:
                tp_PixelBin(const int, const int, pixelListType&, const int, const double, const double);
                ~tp_PixelBin();
                void print() const;
                int getId() const;
                int getNumPix() const;
                int getNumMPix() const;
                macroPixelListType getMacroPixels() const;

        private:
                const int _binId; 
                const int _size; 
                int _numPix; 
                macroPixelListType _macroPixels; 
};

typedef std::vector<tp_PixelBin*> pixelBinListType;

class tp_PixelRoad {
        public:
                tp_PixelRoad(macroPixelPairType, pixelBinListType&, const double*);
                ~tp_PixelRoad();
                void print() const;
                bool isValid() const;
                int getNumPix() const;
                int getNumMPix() const;
                double getChi2() const;
                macroPixelListType getMacroPixels() const;

        private:
                const int _mpId1; 
                const int _mpId2; 
                bool _valid; 
                int _numPix; 
                double _chi2ByNdf; 
                std::vector<double> _sList; 
                macroPixelListType _macroPixels; 
};

class tp_PixelSegment {
        public:
                tp_PixelSegment(const int, const int, const double, macroPixelListType&);
                ~tp_PixelSegment();
                void print() const;
                int getNumPar() const;
                int getLevel() const;
                double getChi2() const;
                int getNdf() const;
                double getLength() const;
                void getRefPoint(double*) const;
                void getPar(double *) const;
                const TVectorD& getPar() const;
                const TMatrixDSym& getCov() const;
                bool match(tp_PixelSegment*, const double, const double) const;
                macroPixelListType getMacroPixels() const;
                void getLCIOStateAtRefPoint(const double*, TVectorD&, TMatrixDSym&) const;

        private:
                const int _segId; 
                const int _level; 
                const double _bzc; 
                const int _npar; 
                macroPixelListType _macroPixels; 
                double _refX; 
                double _refY; 
                double _refZ; 
                double _length; 
                int _ndf; 
                double _chi2; 
                TVectorD _parameters; 
                TMatrixDSym _covariance; 
};

typedef std::vector<tp_PixelSegment*> pixelSegmentListType;
typedef std::map<int, pixelSegmentListType> pixelSegmentListMapType;

class tp_PixelChip {
        public:
                tp_PixelChip(const int, pixelListType&, const int, const double);
                ~tp_PixelChip();
                void print() const;
                int getId() const;
                int getNumPix() const;
                int getNumMPix() const;
                int getNumBins() const;
                int findSegments(const double, const int*, const double*);
                pixelSegmentListType getPixelSegments() const;

        private:
                const int _chipId; 
                const int _size; 
                int _numPix; 
                int _numMPix; 
                pixelBinListType _pixelBins; 
                pixelSegmentListType _pixelSegments; 
};

typedef std::vector<tp_PixelChip*> pixelChipListType;

class tp_PixelSegmentCombiner {
        public:
                tp_PixelSegmentCombiner(const double);
                pixelSegmentListType run(const int, const int, pixelSegmentListType&, const double, const double);

        private:
                double _bzc; 
};

} // namespace marlintpc
#endif // TIMEPIXLOCALROADSEARCHPROCESSOR_H