PhotodotReconstructionProcessor.h

#ifdef USE_LCCD

#ifndef PHOTODOTRECONSTRUCTIONPROCESSOR_H_
#define PHOTODOTRECONSTRUCTIONPROCESSOR_H_ 1

//Marlin
#include <marlin/Processor.h> // Integral for any processor

//gear
#include <gear/PadRowLayout2D.h>
#include <gearimpl/GlobalPadIndex.h>

//lcio
#include <IMPL/TrackerPulseImpl.h>

//marlinTPC
#include "HitCandidate.h"

namespace marlintpc
{


class PhotodotReconstructionProcessor : public marlin::Processor
{

    public: // Functions for interaction with Marlin

        virtual Processor * newProcessor()
        {
            return new PhotodotReconstructionProcessor ;
        }
        PhotodotReconstructionProcessor();
        ~PhotodotReconstructionProcessor();

        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:

        struct Photodot
        {
            // Cartesian constructor
            Photodot(double x, double y, double diameter) :
                    _x(x),
                    _y(y),
                    _r(sqrt(x*x + y*y)),
                    _phi(atan2(y, x)),
                    _diameter(diameter) {};
            // Polar constructor
            /* The extra integer argument serves simply to differentiate the two
             * constructor types. Its value is irrelevant.
             */
            Photodot(double r, double phi, double diameter, int alt_type) :
                    _x(r * cos(phi)),
                    _y(r * sin(phi)),
                    _r(r),
                    _phi(phi),
                    _diameter(diameter) {};
            double _x;
            double _y;
            double _r;
            double _phi;
            double _diameter;
        };

        void findNearestHit(Photodot thisPhotodot, int &module, int &pad);

        int findCentreColumn(int module, int pad);

        gear::Vector2D findGausHitCentre(int module, int columnCentre);

        gear::Vector3D findMeanHitCentre(int module, int columnCentre, float* covMatrix);

        gear::Vector3D calculatePositionsAndErrors(const HitCandidate &cand, float* covMatrix);
        void findPhotodotPulses(LCCollection* electron_cloud_collection);

        double getPadCharge(int module, int padIndex);

        std::string _geometry_filename;

        std::string _input_pulses_collection_name;

        std::string _input_hitPosition_collection_name;

        std::string _output_reconstuctedPhototdots_collection_name;

        std::string _output_photodot_collection_name;

        std::vector< Photodot > _photodots;
        std::vector< Photodot > _expected_photodots;

        std::multimap<gear::GlobalPadIndex , EVENT::TrackerPulse * > * _pulses;

        std::string _geometry_type;

        double _diffusion;

        /* The following parameters describe the geometry of the TPC
         */
        double _omega_tau;

        double _drift_velocity;

        double _tpc_outer_radius;

        double _tpc_inner_radius;

        double _outer_z;

        double _inner_z;


        double _sigma;

        bool _useGaus;

}; // /PhotodotReconstructionProcessor

} // /namespace marlintpc

#endif //PHOTODOTRECONSTRUCTIONPROCESSOR_H_

#endif //USE_LCCD