TPCHitMap.h

#ifndef TPCHITMAP_H
#define TPCHITMAP_H

#include <map>
#include <set>
#include <string>
#include <limits>
#include <sstream>

#include <gear/TPCParameters.h>
#include <EVENT/LCEvent.h>
#include <IMPL/TrackerHitImpl.h>
#include <TVector3.h>
#include <kaldet/GearTPCKalDetector.h>
#include <kaldet/GearTPCCylinderMeasLayer.h>



namespace marlintpc
{

class TPCHitDomain;
 
struct MarlinTPCHit
{
        EVENT::TrackerHit* hit;
        bool isUsed;    

        MarlinTPCHit(EVENT::TrackerHit* _hit_ = 0, bool _isUsed_ = false)
                        : hit(_hit_), isUsed(_isUsed_)
        {}

        //We just compare the z coordinate and hit pointer, ignore isUsed.
        //Then, if a MarlinTPCHit type hit, which has the same z and pointer with
        //a MarlinTPCHit in a container(say, a set), can not be added.
        bool operator<(const MarlinTPCHit &h) const
        {
                //Mainly sort the hits according to the z coordinate
                if( sqrt(hit->getPosition()[2]) == sqrt(h.hit->getPosition()[2]) )
                {
                        return hit < h.hit;
                }
                else
                {
                        return sqrt(hit->getPosition()[2]) < sqrt(h.hit->getPosition()[2]);
                }
        }

        bool operator == (const MarlinTPCHit &h) const
        {
                return hit == h.hit;
        }

        MarlinTPCHit& operator = (const MarlinTPCHit &h) 
        {
                hit = h.hit;
                isUsed = h.isUsed;

                return *this;
        }
};

typedef std::set< MarlinTPCHit >::iterator HitSetIter;
typedef std::pair<int, int> ModuleRow;
typedef std::map< ModuleRow, std::set< MarlinTPCHit > > HitContainer;

struct ModuleRowHit
{
    int module;
    int row;
        MarlinTPCHit tpcHit;

    ModuleRowHit( int _module_ = std::numeric_limits<int>::max(),
                          int _row_    = std::numeric_limits<int>::max(),
                          MarlinTPCHit _tpcHit_= MarlinTPCHit() )
                  : module(_module_), row(_row_), tpcHit(_tpcHit_)
    {}

        bool operator ==(const ModuleRowHit &h) const
        {
                return module == h.module && row == h.row && tpcHit == h.tpcHit;
        }

    double const * getHitPosition() const { return tpcHit.hit->getPosition(); }
        EVENT::TrackerHit* getTrackerHit() const {return tpcHit.hit;}

        bool isUsed() const {return tpcHit.isUsed;}
};

class ModuleRowHitListSorter
{
    public:
        ModuleRowHitListSorter(TVector3 refPos): _referencePosition(refPos){}
   
            // the comparison operator for sort
        bool operator()(ModuleRowHit const & mrh1, ModuleRowHit const & mrh2) const;

    private:
        TVector3 _referencePosition;
};

class TPCHitMap
{
    public:
        TPCHitMap(gear::TPCParameters        const * tpcParameters, 
                                  kaldet::GearTPCKalDetector const * det,
                                  std::string                modulesNotUsed = std::string("-1")); 

        virtual ~TPCHitMap();

                void fillEventHits(EVENT::LCCollection const * inputHits);

        void removeHits(std::vector<ModuleRowHit>& hitlist);

        void removeHit(ModuleRowHit hit);

        void clear();

        size_t size() const ;

        ModuleRowHit getFirstHit(int mode = 0);

            bool isEmpty() const;
 
            std::list<ModuleRowHit> getHitsInDomain(std::set< ModuleRow > const & moduleRowsInDomain);

                ModuleRowHit getHitInDomain(std::set< ModuleRow > const & moduleRowsInDomain, 
                                                                                ModuleRowHit hit);

        static double getHitsDistance(ModuleRowHit& hit1, ModuleRowHit& hit2);

            std::list< ModuleRow > getActiveModuleRows();

            std::set< MarlinTPCHit > const & getHitsInModuleRow(int module, int row);

                void setHitUsed(const ModuleRowHit& hit, bool used = true);

                int getLayerIndex(int module, int row);

    protected:
        HitContainer _hitContainer;

            std::map< int, std::set<ModuleRow> > _indexModuleRow;

            gear::TPCParameters const *_tpcParameters;

            size_t _nHits; 

                kaldet::GearTPCKalDetector const *      _kalDetector;

                std::set<int> _modulesNotUsedSet;

};

}
#endif //TPCHITMAP_H