MTDArrayBuffer.h

Go to the documentation of this file.

#ifndef RecoLocalTracker_FTLClusterizer_MTDArrayBuffer_H
#define RecoLocalTracker_FTLClusterizer_MTDArrayBuffer_H

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------

// We use FTLHitPos which is an inner class of FTLCluster:
#include "DataFormats/FTLRecHit/interface/FTLCluster.h"

#include <vector>
#include <iostream>

class MTDArrayBuffer 
{
 public:
  typedef unsigned int uint;
  
  inline MTDArrayBuffer( uint rows, uint cols);
  inline MTDArrayBuffer( ){}
  
  inline void setSize( uint rows, uint cols);

  inline float energy( uint row, uint col) const;
  inline float energy( const FTLCluster::FTLHitPos&) const;
  inline float time( uint row, uint col) const;
  inline float time( const FTLCluster::FTLHitPos&) const;
  inline float time_error( uint row, uint col) const;
  inline float time_error( const FTLCluster::FTLHitPos&) const;

  inline uint rows() const { return nrows;}
  inline uint columns() const { return ncols;}

  inline bool inside(uint row, uint col) const;

  inline void clear(uint row, uint col) 
  {
    set_energy( row, col, 0.);
    set_time( row, col, 0.);
    set_time_error( row, col, 0.);
  }
  inline void clear(const FTLCluster::FTLHitPos& pos) 
  {
    clear(pos.row(),pos.col());
  }

  inline void set( uint row, uint col, float energy, float time, float time_error);
  inline void set( const FTLCluster::FTLHitPos&, float energy, float time, float time_error);

  inline void set_energy( uint row, uint col, float energy);
  inline void set_energy( const FTLCluster::FTLHitPos&, float energy);
  inline void add_energy( uint row, uint col, float energy);

  inline void set_time( uint row, uint col, float time);
  inline void set_time( const FTLCluster::FTLHitPos&, float time);

  inline void set_time_error( uint row, uint col, float time_error);
  inline void set_time_error( const FTLCluster::FTLHitPos&, float time_error);

  uint size() const { return hitEnergy_vec.size();}

  uint index( uint row, uint col) const {return col*nrows+row;}
  uint index( const FTLCluster::FTLHitPos& pix) const { return index(pix.row(), pix.col()); }

 private:
  std::vector<float> hitEnergy_vec;   
  std::vector<float> hitTime_vec;  
  std::vector<float> hitTimeError_vec;   
  uint nrows;
  uint ncols;
};

MTDArrayBuffer::MTDArrayBuffer( uint rows, uint cols) 
  : hitEnergy_vec(rows*cols,0), hitTime_vec(rows*cols,0), hitTimeError_vec(rows*cols,0),  nrows(rows), ncols(cols) {}

void MTDArrayBuffer::setSize( uint rows, uint cols) {
  hitEnergy_vec.resize(rows*cols,0);
  hitTime_vec.resize(rows*cols,0);
  hitTimeError_vec.resize(rows*cols,0);
  nrows = rows;
  ncols = cols;
}

bool MTDArrayBuffer::inside(uint row, uint col) const 
{
  return ( row < nrows && col < ncols);
}

float MTDArrayBuffer::energy(uint row, uint col) const { return hitEnergy_vec[index(row,col)];}
float MTDArrayBuffer::energy(const FTLCluster::FTLHitPos& pix) const {return hitEnergy_vec[index(pix)];}

float MTDArrayBuffer::time(uint row, uint col) const  { return hitTime_vec[index(row,col)];}
float MTDArrayBuffer::time(const FTLCluster::FTLHitPos& pix) const {return hitTime_vec[index(pix)];}

float MTDArrayBuffer::time_error(uint row, uint col) const  { return hitTimeError_vec[index(row,col)];}
float MTDArrayBuffer::time_error(const FTLCluster::FTLHitPos& pix) const {return hitTimeError_vec[index(pix)];}

void MTDArrayBuffer::set( uint row, uint col, float energy, float time, float time_error) 
{
  hitEnergy_vec[index(row,col)] = energy;
  hitTime_vec[index(row,col)] = time;
  hitTimeError_vec[index(row,col)] = time_error;
}
void MTDArrayBuffer::set( const FTLCluster::FTLHitPos& pix, float energy, float time, float time_error) 
{
  set( pix.row(), pix.col(), energy, time, time_error);
}

void MTDArrayBuffer::set_energy( uint row, uint col, float energy) 
{
  hitEnergy_vec[index(row,col)] = energy;
}
void MTDArrayBuffer::set_energy( const FTLCluster::FTLHitPos& pix, float energy)
{
  hitEnergy_vec[index(pix)] = energy;
}
void MTDArrayBuffer::add_energy( uint row, uint col, float energy)
{
  hitEnergy_vec[index(row,col)] += energy;
}

void MTDArrayBuffer::set_time( uint row, uint col, float time) 
{
  hitTime_vec[index(row,col)] = time;
}
void MTDArrayBuffer::set_time( const FTLCluster::FTLHitPos& pix, float time)
{
  hitTime_vec[index(pix)] = time;
}

void MTDArrayBuffer::set_time_error( uint row, uint col, float time_error) 
{
  hitTimeError_vec[index(row,col)] = time_error;
}
void MTDArrayBuffer::set_time_error( const FTLCluster::FTLHitPos& pix, float time_error)
{
  hitTimeError_vec[index(pix)] = time_error;
}

#endif