RowBasedHitFinderProcessor.h

#ifndef ROWBASEDHITFINDERPROCESSOR_H
#define ROWBASEDHITFINDERPROCESSOR_H

// MARLIN
#include "marlin/Processor.h"
#include "marlin/Global.h"

//LCIO
#include "lcio.h"
#include "EVENT/LCCollection.h"
#include "IMPL/LCCollectionVec.h"
#include "EVENT/TrackerPulse.h"

//GEAR
#include "gear/TPCParameters.h"

// C++
#include <string>
#include <vector>
#include <map>

// MARLINTPC
#include "ChannelCorrectionListener.h"
#include "TPCConditionsListener.h"

namespace marlintpc
{

    class RowBasedHitFinderProcessor : public marlin::Processor
    {
        public:

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

            RowBasedHitFinderProcessor() ;

            virtual void init() ;

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

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


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


            virtual void end() ;

        private:
            std::string _inputTrackerPulsesCollectionName ;

            std::string _outputTrackerHitsCollectionName ;

            std::string _inputTPCConditionsCollectionName;

            std::string  _channelCorrectionCollectionName;

            std::vector<int> _deadChannelIndicesOverride;

            bool _outputHitsPersistent;

            int _deprecated;

            int _maxEmptyChannelsOverride;

            int _maxDeadChannelsOverride;

            int _minHitSizeOverride;

            float _minMaxPulseSliceHeightOverride;

            float _maxTimeSpreadOverride;

            float _driftVelocityOverride;

            bool _chargeIsCalibrated;

            float _chargeConversionFactorOverride;

            ChannelCorrectionListener* _channelCorrectionListener;

            TPCConditionsListener* _tpcConditionsListener;

            // a helper class -- does it make sense to externalise it from the HitFinder?
            class hitCandidate
            {
                public:
                    hitCandidate(EVENT::TrackerPulse*);

                    void addPulse(EVENT::TrackerPulse*);
                    void addDeadChannel();

                    int qualityFlag;

                    const EVENT::TrackerPulse* getMaximumPulse() const
                    {
                        return _maxPulse;
                    };
                    double getCharge() const;
                    double getChargeMeasError() const;
                    double getMaxPulseHeight();
                    const std::vector<EVENT::TrackerPulse*>& getPulses() const
                    {
                        return _thePulses;
                    };
                    unsigned int getWidth() const;

                private:
                    hitCandidate()
                    {
                        ;
                    };
                    std::vector<EVENT::TrackerPulse*> _thePulses;
                    EVENT::TrackerPulse* _maxPulse;
                    double _maxPulseCharge;
                    int _numberOfDeadChannels;
            };

            void _sortPulses(EVENT::LCCollection*, const gear::TPCParameters&,
                             std::map<int, std::map<int, std::vector<EVENT::TrackerPulse*>* >* >&);
            void _findHitCandidates(std::map<int, std::map<int, std::vector<EVENT::TrackerPulse*>* >* >&,
                                    const gear::TPCParameters&,
                                    std::map<int, std::vector<RowBasedHitFinderProcessor::hitCandidate> >&);
            void _createHitCollection(std::map<int, std::vector<RowBasedHitFinderProcessor::hitCandidate> >&,
                                      const gear::TPCParameters&, IMPL::LCCollectionVec*);

            bool _pulseComparator(EVENT::TrackerPulse*, EVENT::TrackerPulse*);
            EVENT::TrackerPulse* _findHighestPulseInRow(std::vector<EVENT::TrackerPulse*>&);
            bool _maxPulseHeightCheck(EVENT::TrackerPulse*);
            void _addNeighbourPulses(hitCandidate&, const gear::TPCParameters&, std::vector<EVENT::TrackerPulse*>&);
            std::vector<EVENT::TrackerPulse*>::iterator _findBestNeighbourPulseMatch
            (std::vector<std::vector<EVENT::TrackerPulse*>::iterator>&, float);

            bool _hitIsValid(const RowBasedHitFinderProcessor::hitCandidate&);
            gear::Vector3D _calculatePositionsAndErrors(const RowBasedHitFinderProcessor::hitCandidate&, const gear::TPCParameters&, float*);
            double _convertCharge(const RowBasedHitFinderProcessor::hitCandidate&);

            unsigned int _getMaxDeadChannels();
            int _getMinHitSize();
            double _getMinMaxPulseSliceHeight();
            double _getMaxTimeSpread();
            double _getDriftVelocity();
            bool _padIsDead(const int, const int);
            bool _padIsNoisy(const int, const int);
            double _getChargeConversionFactor();

    };
}//namespace marlintpc
#endif//ROWBASEDHITFINDERPROCESSOR_H