HitMap.h

Go to the documentation of this file.

#ifndef NOISEHITMAP__H
#define NOISEHITMAP__H
#include "DDTBaseDataProducts/DAQHit.h"

#include <exception>
#include <array>

namespace novaddt{
namespace calib{

    template <size_t Nx, size_t Ny> 
    struct dimensions{
       enum {NX=Nx, NY=Ny, length=Nx*Ny};
       static size_t index(size_t nx, size_t ny){return nx+ny*NX;}
    };

    template <typename T, typename Dimension> class HitMap;

    const size_t FD_NUM_PLANES = 896;
    const size_t FD_NUM_CELLS  = 384;
    const size_t ND_NUM_PLANES = 256;
    const size_t ND_NUM_CELLS  = 96; 
    using FDHitMap=HitMap<double,dimensions<FD_NUM_PLANES,FD_NUM_CELLS>>;
    using NDHitMap=HitMap<double,dimensions<ND_NUM_PLANES,ND_NUM_CELLS>>;
    }
}

//a template class to keep array of Planes*Cells, accessible by hits
template <typename T, typename Dimension>
class novaddt::calib::HitMap: public Dimension{
public:
    HitMap() { }
    void reset(){std::fill(data.begin(),data.end(),0);}
    static size_t Nplanes() {return Dimension::NX;}
    static size_t Ncells () {return Dimension::NY;}
    static size_t Length()  {return Dimension::length;}
    void Scale(T koeff){
        /// scale the map contents (normalize to N events)
        for(auto &d:data){
            d*=koeff;
        }
    }
///access operators by plane&cell numbers
    T& at(novaddt::Plane plane, novaddt::Cell cell)
    { return data[Dimension::index(plane.val,cell.val)]; }
    const T& at(novaddt::Plane plane, novaddt::Cell cell) const
    { return data[Dimension::index(plane.val,cell.val)]; }

    T& operator()  (novaddt::Plane plane, novaddt::Cell cell)
    { return at(plane,cell); }

const T& operator()  (novaddt::Plane plane, novaddt::Cell cell) const
    { return at(plane,cell); }
///access operators by hit
      T& operator [](const novaddt::DAQHit& h)
    { return at(h.Plane(),h.Cell()); }

const T& operator [](const novaddt::DAQHit& h) const
    { return at(h.Plane(),h.Cell()); }
///access operators by index
const T& operator [](size_t n){return data[n];}

public:
    std::array<T,Dimension::length> data;
};

//couple of useful methods: serializing map
std::istream& operator >> (std::istream& s, novaddt::calib::FDHitMap& map)
{
        size_t length = sizeof(map);
        char *buffer=reinterpret_cast<char*>(&map);
        s.read(buffer,length);
        return s; 
}

std::ostream& operator << (std::ostream& s, const novaddt::calib::FDHitMap& map)
{
        size_t length = sizeof(map);
        const char *buffer=reinterpret_cast<const char*>(&map);
        s.write(buffer,length);
        return s;
}
#endif