HoughPlaneMulti2.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to represent multi Hough parameter planes (version 2)
//-----------------------------------------------------------------------------
 
#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