PufitMultiGrid.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef TRIGEFMISSINGET_PUFITMULTIGRID_H
#define TRIGEFMISSINGET_PUFITMULTIGRID_H
 
#include "TrigEFMissingET/PeriodicGridBase.h"
#include "TrigEFMissingET/PufitGrid.h"
#include <cstdint>
#include <limits>
#include <type_traits>
 
namespace HLT
{
  namespace MET
  {
    constexpr bool isPow2(std::size_t i)
    {
      // An int is a power of 2 if it only contains one 'on' bit
      // We check for this by shifting an int until its first bit is 1. Then it
      // is a power of two if that is the only bit set.
      // We also need a check if this is 0 otherwise the recursion will never
      // end
      if (i == 0)
        // 0 is *not* a power of 2
        return false;
      else if (i == 1)
        // 1 is a power of 2
        return true;
      else if (i & 1)
        // If we're not 1, but the '1' bit is set then this can't be a power of 2
        return false;
      else
        // shifting to the right esse
        return isPow2(i >> 1);
    }

    constexpr uint16_t intLog2(std::size_t i, uint16_t tmp = 0)
    {
      if (i == 0)
        return UINT16_MAX;
      else if (i == 1)
        return tmp;
      else
        return intLog2(i >> 1, tmp + 1);
    }

    template <std::size_t N>
    class PufitMultiGrid : public PeriodicGridBase
    {
      static_assert(N > 0, "N must be greater than 0");
      // The C++ standard only guarantees that std::size_t has a bit width of
      // at least 16
      static_assert(N < 17, "N must be no greater than 16");
 
    public:
      constexpr static std::size_t All = (1 << N) - 1;
      constexpr static std::size_t NCategories = N;

      class Tower : public PeriodicGridBase::Tower
      {
        friend class PufitMulitGrid;
 
      public:
        Tower(PufitMultiGrid *parent, std::size_t index);
 
        Tower(const Tower&) = default;

        Tower &operator=(const Tower &other);

        double ex(std::size_t type = All) const;

        double ey(std::size_t type = All) const;

        double ez(std::size_t type = All) const;

        double sumEt(std::size_t type = All) const;

        double sumE(std::size_t type = All) const;

        double phi(std::size_t type = All) const;

        double eta(std::size_t type = All) const;

        bool masked() const;

        void mask(bool value = true);

        const PufitMultiGrid *grid() const override;

        SignedKinematics kinematics(std::size_t type = All) const;

        operator SignedKinematics() const;

        Tower &operator+=(const Tower &other);
        Tower &operator-=(const Tower &other);

        template <std::size_t I,
                  typename = typename std::enable_if<isPow2(I)>::type,
                  typename = typename std::enable_if<I <= All>::type>
        PufitGrid::Tower &get()
        {
          return subTower(intLog2(I));
        }

        template <std::size_t I,
                  typename = typename std::enable_if<isPow2(I)>::type,
                  typename = typename std::enable_if<I <= All>::type>
        const PufitGrid::Tower &get() const
        {
          return subTower(intLog2(I));
        }
 
      private:
        PufitMultiGrid *const m_parent;

        bool m_mask{false};

        PufitGrid::Tower &subTower(std::size_t ii)
        {
          return m_parent->m_grids[ii][index()];
        }

        const PufitGrid::Tower &subTower(std::size_t ii) const
        {
          return m_parent->m_grids[ii][index()];
        }

        void applyToAll(PufitGrid::Tower &(PufitGrid::Tower::*f)(const PufitGrid::Tower &), const PufitMultiGrid::Tower &other)
        {
          for (std::size_t ii = 0; ii < N; ++ii)
            (subTower(ii).*f)(other.subTower(ii));
        }

        template <typename T>
        typename std::decay<T>::type sumOver(int type, T (PufitGrid::Tower::*f)() const) const
        {
          typename std::decay<T>::type val{};
          for (std::size_t ii = 0; ii < N; ++ii)
            if (1 << ii & type)
              val += (subTower(ii).*f)();
          return val;
        }
 
      }; //> end class Tower

      PufitMultiGrid(
          double maxEta,
          std::size_t nEtaTowers,
          std::size_t nPhiTowers,
          bool displaceEta = false,
          bool displacePhi = false);

      PufitMultiGrid(const GridParameters &parameters);

      PufitMultiGrid(const PufitMultiGrid &other);

      PufitMultiGrid &operator=(const PufitMultiGrid &other);

      void reset();

      Tower &operator[](const std::pair<std::size_t, std::size_t> &indices);
      const Tower &operator[](const std::pair<std::size_t, std::size_t> &indices) const;

      Tower &operator[](std::size_t index);
      const Tower &operator[](std::size_t index) const;

      typename std::vector<Tower>::iterator begin();
      typename std::vector<Tower>::const_iterator begin() const;
      typename std::vector<Tower>::iterator end();
      typename std::vector<Tower>::const_iterator end() const;
 
      // All of these fail if the grid parameters do not match!
      PufitMultiGrid &operator+=(const PufitMultiGrid &other);
      PufitMultiGrid &operator-=(const PufitMultiGrid &other);

      template <std::size_t I,
                typename = typename std::enable_if<isPow2(I)>::type,
                typename = typename std::enable_if<I <= All>::type>
      PufitGrid &get()
      {
        return m_grids[intLog2(I)];
      }

      template <std::size_t I,
                typename = typename std::enable_if<isPow2(I)>::type,
                typename = typename std::enable_if<I <= All>::type>
      const PufitGrid &get() const
      {
        return m_grids[intLog2(I)];
      }

      PufitGrid get(std::size_t type) const;
 
    private:
      std::array<PufitGrid, N> m_grids;
      std::vector<Tower> m_towers;
    }; //> end class PufitMultiGrid

    template <typename Grid>
    struct PufitMultiGridSet
    {
      PufitMultiGridSet(double maxEta, std::size_t nEta, std::size_t nPhi);
      std::array<Grid, 4> grids;

      Grid &operator[](GridDisplacement displacement)
      {
        return grids[displacement];
      }

      const Grid &operator[](GridDisplacement displacement) const
      {
        return grids[displacement];
      }

      template <std::size_t I>
      struct Element
      {
        Element(PufitMultiGridSet &parent);
        PufitMultiGridSet &parent;
        Element &operator+=(const SignedKinematics &kin);
        Element &operator-=(const SignedKinematics &kin);
      }; //> end struct Element<I>
 
      template <std::size_t I,
                typename = typename std::enable_if<isPow2(I)>::type,
                typename = typename std::enable_if<I <= Grid::All>::type>
      Element<I> get();
 
      PufitGridSet get(std::size_t type) const;
    }; //> end struct PufitMultiGridSet<Grid>
  }    // namespace MET
} // namespace HLT
 
#include "TrigEFMissingET/PufitMultiGrid.icc"
 
#endif //> !TRIGEFMISSINGET_PUFITMULTIGRID_H