HoughPlaneBoolean.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 a Hough parameter plane with simple
//               counter.
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCHoughPlaneBoolean_FLAG_
#define TRGCDCHoughPlaneBoolean_FLAG_
 
#include <string.h>
#include "trg/cdc/HoughPlaneBase.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCHPlaneBoolean TRGCDCHoughPlaneBoolean
#endif
 
namespace Belle2 {

  class TRGCDCHoughPlaneBoolean : public TRGCDCHoughPlaneBase {
 
  public:
    TRGCDCHoughPlaneBoolean(const std::string& name,
                            const TRGCDCHoughTransformation& transformation,
                            unsigned nX,
                            float xMin,
                            float xMax,
                            unsigned nY,
                            float yMin,
                            float yMax);

    virtual ~TRGCDCHoughPlaneBoolean();

    TRGCDCHoughPlaneBoolean(TRGCDCHoughPlaneBoolean&) = delete;

    TRGCDCHoughPlaneBoolean& operator=(TRGCDCHoughPlaneBoolean&) = delete;
 
  public:// Selectors

    unsigned entry(unsigned id) const override;
 
    unsigned entry(unsigned x, unsigned y) const override;
    int maxEntry(void) const override;

    const std::vector<unsigned>& patternId(unsigned cellId) const;
 
  public:// Modifiers

    unsigned setEntry(unsigned serialId, unsigned n) override;

    // cppcheck-suppress virtualCallInConstructor
    void clear(void) override;

    void vote(float rx,
              float ry,
              int weight = 1) override;
 
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Woverloaded-virtual"
#endif

    // using TRGCDCHoughPlaneBase::vote; // to be checked
    void vote(float rx,
              float ry,
              float charge,
              int weight = 1);

    // using TRGCDCHoughPlaneBase::vote; // to be checked
    void vote(unsigned patternId, int weight);
 
#ifdef __clang__
#pragma clang diagnostic pop
#endif

    void voteUsedInTrasan(float rx,
                          float ry,
                          float charge,
                          int weight = 1);

    void registerPattern(unsigned id) override;

    void preparePatterns(unsigned nPatterns);
 
  protected:

    void add(unsigned cellId, int weight) override;
 
  private:
    unsigned _n;
    unsigned* const _cell;
    unsigned _nPatterns;
    unsigned** _patterns;
    unsigned* _nActive;

    std::vector<unsigned>* _reverse;
 
    friend class TRGCDCHoughPlaneMulti2;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  unsigned
  TRGCDCHoughPlaneBoolean::setEntry(unsigned serialId, unsigned n)
  {
    const unsigned b0 = serialId / 32;
    const unsigned b1 = serialId % 32;
 
#ifdef TRASAN_DEBUG
    if (b0 >= _n)
      std::cout << "TRGCDCHoughPlaneBoolean !!! given serialId is too large : "
                << "max=" << _n * 32 << ",serialId=" << serialId << std::endl;
#endif
 
    if (n > 0)
      _cell[b0] |= (1 << b1);
    else
      _cell[b0] &= (~(1 << b1));
 
    return (_cell[b0] >> b1) & 1;
  }
 
  inline
  void
  TRGCDCHoughPlaneBoolean::clear(void)
  {
    memset(_cell, 0, _n * sizeof(unsigned));
    TRGCDCHoughPlaneBase::clear();
  }
 
  inline
  void
  TRGCDCHoughPlaneBoolean::vote(float rx,
                                float ry,
                                int weight)
  {
    vote(rx, ry, 0, weight);
  }
 
  inline
  unsigned
  TRGCDCHoughPlaneBoolean::entry(unsigned serialId) const
  {
    const unsigned b0 = serialId / 32;
    const unsigned b1 = serialId % 32;
 
#ifdef TRASAN_DEBUG
    if (b0 >= _n)
      std::cout << "TRGCDCHoughPlaneBoolean::entry !!! given serialId is too large"
                << " : "
                << "max=" << _n * 32 << ",serialId=" << serialId << std::endl;
#endif
 
    return (_cell[b0] >> b1) & 1;
  }
 
  inline
  unsigned
  TRGCDCHoughPlaneBoolean::entry(unsigned x, unsigned y) const
  {
    return entry(nY() * x + y);
  }
 
  inline
  int
  TRGCDCHoughPlaneBoolean::maxEntry(void) const
  {
#ifdef TRASAN_DEBUG
    std::cout << "TRGCDCHoughPlaneBoolean::maxEntry !!! "
              << " this function has no meaning for TRGCDCHoughPlaneBooolean object"
              << std::endl;
#endif
    return 1;
  }
 
  inline
  void
  TRGCDCHoughPlaneBoolean::add(unsigned a, int b)
  {
    if (b > 0)
      setEntry(a, 1);
    else
      setEntry(a, 0);
  }
 
  inline
  const std::vector<unsigned>&
  TRGCDCHoughPlaneBoolean:: patternId(unsigned cellId) const
  {
    return _reverse[cellId];
  }

} // namespace Belle2
 
#endif