RowBasedPadPulseRoadSearchProcessor.h

Go to the documentation of this file.

#ifndef ROWBASEDPADPULSEROADSEARCHPROCESSOR_H
#define ROWBASEDPADPULSEROADSEARCHPROCESSOR_H

#include "RowTripletBasedTrackFinderProcessor.h"

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

#include <gear/TPCModule.h>

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

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

namespace marlintpc {

class RowBasedPadPulseRoadSearchProcessor: public marlin::Processor {
        public:

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

                RowBasedPadPulseRoadSearchProcessor();

                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 _inputTrackerPulsesColName; 
                std::string _outputTrackerHitsColName;  
                std::string _outputTrackColName;  
                double _bfieldScaleFactor; 
                double _driftVelocity; 
                int _maxColDiff; 
                double _dtMax; 
                int _maxSeedsInRow; 
                int _minRowDiff; 
                double _maxDxyRoad; 
                double _maxDzRoad; 
                int _minRows; 
                double _rowDensityCut; 
                double _maxVarXY; 
                double _maxOverlapFraction; 
                int _maxColDiffHit; 
                int _minNumPulses; 
                int _maxColGap; 
                double _offsetCol; 
                double _slopeCol; 
                double _offsetDrift; 
                double _slopeDrift; 
                double _offsetRow; 
                double _slopeRow; 
                double _chargeConversionFactor; 
                double _segCut; 
                bool _refAtPCA; 
                bool _skipRoadSearch; 
                bool _skipMultiplePulses; 

        private:

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

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

typedef std::list<int> seedIdListType;


class pb_Pulse {
        public:
                pb_Pulse(const int iPulse, const EVENT::TrackerPulse& aPulse, const gear::TPCModule& aModule, const double zPos);
                void print() const;
                int getPulseNum() const;
                int getModule() const;
                int getPadId() const;
                int getRow() const;
                int getColumn() const;
                int getQuality() const;
                double getCharge() const;
                double getRelCharge() const;
                double getTime() const;
                double getX() const;
                double getY() const;
                double getZ() const;
                void getPos(double*) const;
                void getCOG(double*) const;
                void getMeasDir(double*) const;
                double getPhiMeas() const;
                bool isMaxPulse() const;
                bool inSeed() const;
                int getNumSeeds() const;
                void addSeed(int);
                void removeSeed(int);
                void clearSeeds();
                const seedIdListType& getSeedIdList() const;
                int getSeedId() const;
                void addNeighbour(pb_Pulse*);
                bool inHit() const;
                void addToHit();
                int getIndex() const;
                void setIndex(int);
                int getHitNum() const;
                void setHitNum(int);

        private:
                const int _pulseNum; 
                const int _pulseModule; 
                const int _pulsePadID; 
                const int _pulseRow; 
                const int _pulseCol; 
                const int _pulseQuality; 
                const double _pulseCharge; 
                const double _pulseTime; 
                const double _pulseX; 
                const double _pulseY; 
                const double _pulseZ; 
                const double _pulsePhiMeas; 
                const double _pulseDirX; 
                const double _pulseDirY; 
                int _firstCol; 
                int _lastCol; 
                double _maxCharge; 
                double _sumCharge; 
                double _sumChargeDist; 
                seedIdListType _seeds; 
                bool _inHit; 
                int _indexCol; 
                int _hitNum; 
};

typedef std::vector<pb_Pulse*> pulseListType;
typedef std::map<int, pulseListType> rowPulseMapType;
typedef std::map<int, rowPulseMapType> modPulseMapType;


class pb_Seed {
        public:
                pb_Seed(const int seedID, const double Bzc, const pulseListType& pulses, const int minRows, const double rowDensityCut,
                                const double maxVarXY);
                pb_Seed(const int seedID, const double Bzc, const pulseListType& pulses);
                void print() const;
                int getSeedId() const;
                bool getValid() const;
                void setInvalid();
                int getNumSeedPulses() const;
                int getNumUniqueSeedPulses() const;
                bool hasAddedPulses() const;
                double getVarXY() const;
                void getRefPoint(double*) const;
                void getPar(double *) const;
                void markPulses();
                void freePulses();
                void addPulse(pb_Pulse*);
                const pulseListType& getPulseList() const;
                void roadSearch(pulseListType& pulses, pulseListType& insidePulses, const double maxDxy, const double maxDz) const;

        private:
                const int _seedId; 
                const double _bzc; 
                const bool _checked; 
                const unsigned int _numPulses; 
                pulseListType _pulseList; 
                bool _valid; 
                double _refX; 
                double _refY; 
                double _refZ; 
                int _npar; 
                double _varXY; 
                double _varZS; 
                TVectorD _parameters; 
                void _fitSeed();

};

typedef std::vector<pb_Seed*> seedListType;


class rb_SegmentMatch {
        public:
                rb_SegmentMatch(const rb_Segment* segment1, const rb_Segment* segment2);
                void print() const;
                int getSegId1() const;
                int getSegId2() const;
                int getFirstRow1() const;
                int getFirstRow2() const;
                int getLastRow1() const;
                int getLastRow2() const;
                bool getValid() const;
                bool overlap(rb_SegmentMatch*) const;
                void setInvalid();

        private:
                const int _segId1; 
                const int _segId2; 
                const int _firstRow1; 
                const int _firstRow2; 
                const int _lastRow1; 
                const int _lastRow2; 
                bool _valid; 
};

typedef std::vector<rb_SegmentMatch*> segMatchListType;
typedef std::map<int, segMatchListType> segMatchMapType;

} // namespace marlintpc
#endif // ROWBASEDPADPULSEROADSEARCHPROCESSOR_H