HoughPlaneMulti2.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : HoughPlaneMulti2.h
// Section  : TRG CDC
// Owner    : Yoshihito Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent multi Hough parameter planes (version 2)
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCHoughPlaneMulti2_FLAG_
#define TRGCDCHoughPlaneMulti2_FLAG_
 
#include "trg/cdc/HoughPlane.h"
#include "trg/cdc/HoughPlaneBoolean.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCHPlaneMulti2 TRGCDCHoughPlaneMulti2
#endif
 
#define N_LAYERS 6
 
namespace Belle2 {
  class TRGCDCHoughPlaneMulti2 : public TRGCDCHoughPlane {
 
  public:
 
    TRGCDCHoughPlaneMulti2(const std::string& name,
                           const TRGCDCHoughTransformation& transformation,
                           unsigned nX,
                           float xMin,
                           float xMax,
                           unsigned nY,
                           float yMin,
                           float yMax,
                           unsigned nLayers);
 
    virtual ~TRGCDCHoughPlaneMulti2();
 
  public:// Selectors
 
    unsigned nLayers(void) const;
 
    const std::vector<unsigned>& patternId(unsigned cellId) const;
 
    const std::vector<unsigned>& patternId(unsigned layer,
                                           unsigned cellId) const;
    void dump(unsigned layerId) const;
 
    void dump(const std::string& message = std::string(""),
              const std::string& prefix = std::string("")) const override;
 
  public:// Modifiers
 
    void clear(void) override;
 
    void clear(unsigned layerId);
 
    void clearCells(void);
 
    using TRGCDCHoughPlaneBase::vote; // to be checked
    void vote(float rx,
              float ry,
              int charge,
              unsigned layerId,
              int weight = 1);
 
    // using TRGCDCHoughPlaneBase::vote; // to be checked
    void vote(unsigned layerId, unsigned localId, int weight = 1);
 
    // using TRGCDCHoughPlaneBase::vote; // to be checked
    void vote(float rx,
              float ry,
              unsigned layerId,
              int weight = 1);
 
    using TRGCDCHoughPlane::setEntry; // to be checked
    unsigned setEntry(unsigned serialId, unsigned layerId, unsigned n);
 
    void merge(void);
 
    void mergeOuters(void);
 
    void preparePatterns(unsigned layerId, unsigned nPatterns);
 
    using TRGCDCHoughPlane::registerPattern; // to be checked
    void registerPattern(unsigned layerId, unsigned id);
 
    void finalizePatterns(void);
 
  private:
 
    unsigned _nLayers;
 
    TRGCDCHoughPlaneBoolean* _layers[N_LAYERS];
 
    bool _usage[N_LAYERS];
 
    std::vector<unsigned>* _reverse;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  void
  TRGCDCHoughPlaneMulti2::clear(void)
  {
    for (unsigned i = 0; i < N_LAYERS; i++)
      if (_usage[i]) {
        _layers[i]->clear();
        _usage[i] = false;
      }
    TRGCDCHoughPlane::clear();
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::clearCells(void)
  {
    for (unsigned i = 0; i < N_LAYERS; i++)
      if (_usage[i]) {
        _layers[i]->clear();
        _usage[i] = false;
      }
    TRGCDCHoughPlane::clearCells();
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::clear(unsigned a)
  {
    _layers[a]->clear();
    _usage[a] = false;
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::vote(float rx,
                               float ry,
                               int charge,
                               unsigned layerId,
                               int weight)
  {
    _usage[layerId] = true;
    _layers[layerId]->vote(rx, ry, charge, weight);
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::vote(float rx,
                               float ry,
                               unsigned layerId,
                               int weight)
  {
    _usage[layerId] = true;
    _layers[layerId]->vote(rx, ry, weight);
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::dump(unsigned a) const
  {
    _layers[a]->dump();
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::vote(unsigned a, unsigned b, int c)
  {
    _usage[a] = true;
    _layers[a]->vote(b, c);
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::dump(const std::string& a, const std::string& b) const
  {
    if (a == "merged") {
      TRGCDCHoughPlaneBase::dump(a, b);
    } else if (a == "region") {
      TRGCDCHoughPlaneBase::dump(a, b);
    } else {
      for (unsigned i = 0; i < _nLayers; i++) {
        std::cout << b << name() << " : layer " << i << std::endl;
        _layers[i]->dump();
      }
      std::cout << b << name() << " : merged plane " << std::endl;
      TRGCDCHoughPlaneBase::dump(a, b);
    }
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::registerPattern(unsigned layerId, unsigned id)
  {
    _layers[layerId]->registerPattern(id);
  }
 
  inline
  const std::vector<unsigned>&
  TRGCDCHoughPlaneMulti2:: patternId(unsigned layer,
                                     unsigned cellId) const
  {
    return _layers[layer]->patternId(cellId);
  }
 
  inline
  void
  TRGCDCHoughPlaneMulti2::preparePatterns(unsigned layerId, unsigned nPatterns)
  {
    _layers[layerId]->preparePatterns(nPatterns);
  }
 
  inline
  unsigned
  TRGCDCHoughPlaneMulti2::nLayers(void) const
  {
    return _nLayers;
  }
 
  inline
  unsigned
  TRGCDCHoughPlaneMulti2::setEntry(unsigned serialId,
                                   unsigned layerId,
                                   unsigned n)
  {
    _usage[layerId] = true;
    _layers[layerId]->setEntry(serialId, n);
    return n;
  }
 
} // namespace Belle2
 
#endif