RowBasedFastHoughTransformationProcessor.h

#ifndef ROWBASEDFASTHOUGHTRANSFORMATIONPROCESSOR_H
#define ROWBASEDFASTHOUGHTRANSFORMATIONPROCESSOR_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 RowBasedFastHoughTransformationProcessor: public marlin::Processor {
        public:

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

                RowBasedFastHoughTransformationProcessor();

                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; 
                bool _useXY; 
                bool _useXZ; 
                double _centerXY; 
                double _rangeXY; 
                double _centerXZ; 
                double _rangeXZ; 
                int _minRow; 
                float _fracRow; 
                int _maxRowDiff; 
                int _maxCube; 
                int _minLevel; 
                int _maxLevel; 
                float _effCut; 
                float _purCut; 
                int _maxHitsPerRow; 
                double _unusedCut; 
                int _maxGap; 
                bool _encodedModuleID; 
                bool _refAtPCA; 
                bool _timePixFlag; 

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

typedef std::vector<int> intListType;
typedef std::vector<double> doubleListType;
typedef std::vector<doubleListType> directionsType;

class rb_HyperPlane {
        public:
                rb_HyperPlane(int, rb_Hit*, directionsType&, double = 0.75);
                void print() const;
                int getScaleBits() const;
                int getRow() const;
                rb_Hit* getHit() const;
                intListType getCut() const;
                int getCut(int) const;
                std::vector<intListType> getSteps() const;
                int getStep(int, int) const;

        private:
                int _scaleBits; 
                rb_Hit* _hit; 
                intListType _cut; 
                std::vector<intListType> _steps; 
};

typedef std::vector<rb_HyperPlane*> hyperPlaneListType;

int nCube; 


class rb_HyperCube {
        public:
                rb_HyperCube(unsigned int*, hyperPlaneListType&, intListType&, unsigned int = 0);
                void print() const;
                hitListType divide(int, int, int, int, float, float);

        private:
                unsigned int _setup[2];  
                std::vector<rb_HyperPlane*> _planes; 
                intListType _distances; 
                int _level; 
                int _numChild; 
                unsigned int _dimension; 
};

} // namespace marlintpc
#endif // ROWBASEDFASTHOUGHTRANSFORMATIONPROCESSOR_H