BinUtility.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file BinUtility.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Utilities/BinningData.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Enumerate.hpp"

#include <array>
#include <cstddef>
#include <iostream>
#include <iterator>
#include <memory>
#include <string>
#include <vector>

namespace Acts {

class BinUtility {
 public:
  BinUtility()
      : m_binningData(),
        m_transform(Transform3::Identity()),
        m_itransform(Transform3::Identity()) {
    m_binningData.reserve(3);
  }

  BinUtility(const Transform3& tForm)
      : m_binningData(), m_transform(tForm), m_itransform(tForm.inverse()) {
    m_binningData.reserve(3);
  }

  BinUtility(const BinningData& bData,
             const Transform3& tForm = Transform3::Identity())
      : m_binningData(), m_transform(tForm), m_itransform(tForm.inverse()) {
    m_binningData.reserve(3);
    m_binningData.push_back(bData);
  }

  BinUtility(size_t bins, float min, float max, BinningOption opt = open,
             BinningValue value = binX,
             const Transform3& tForm = Transform3::Identity())
      : m_binningData(), m_transform(tForm), m_itransform(tForm.inverse()) {
    m_binningData.reserve(3);
    m_binningData.push_back(BinningData(opt, value, bins, min, max));
  }

  BinUtility(std::vector<float>& bValues, BinningOption opt = open,
             BinningValue value = binPhi,
             const Transform3& tForm = Transform3::Identity())
      : m_binningData(), m_transform(tForm), m_itransform(tForm.inverse()) {
    m_binningData.reserve(3);
    m_binningData.push_back(BinningData(opt, value, bValues));
  }

  BinUtility(const BinUtility& sbu) = default;

  BinUtility(BinUtility&& sbu) = default;

  BinUtility& operator=(const BinUtility& sbu) {
    if (this != &sbu) {
      m_binningData = sbu.m_binningData;
      m_transform = sbu.m_transform;
      m_itransform = sbu.m_itransform;
    }
    return (*this);
  }

  BinUtility& operator=(BinUtility&&) = default;

  BinUtility& operator+=(const BinUtility& gbu) {
    const std::vector<BinningData>& bData = gbu.binningData();

    m_transform = m_transform * gbu.transform();
    m_itransform = m_transform.inverse();
    if (m_binningData.size() + bData.size() > 3) {
      throw "BinUtility does not support dim > 3";
    }
    m_binningData.insert(m_binningData.end(), bData.begin(), bData.end());
    return (*this);
  }

  ~BinUtility() = default;

  bool operator==(const BinUtility& other) const {
    return (m_transform.isApprox(other.m_transform) and
            m_binningData == other.binningData());
  }

  const std::vector<BinningData>& binningData() const { return m_binningData; }

  size_t bins() const { return bins(0) * bins(1) * bins(2); }

  std::array<size_t, 3> binTriple(const Vector3& position) const {
    const Vector3 bPosition = m_itransform * position;
    // get the dimension
    size_t mdim = m_binningData.size();
    size_t bin0 = m_binningData[0].searchGlobal(bPosition);
    size_t bin1 = mdim > 1 ? m_binningData[1].searchGlobal(bPosition) : 0;
    size_t bin2 = mdim > 2 ? m_binningData[2].searchGlobal(bPosition) : 0;
    return {{bin0, bin1, bin2}};
  }

  size_t bin(const Vector3& position, size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return 0;
    }
    size_t bEval = m_binningData[ba].searchGlobal(m_itransform * position);
    return bEval;
  }

  int nextDirection(const Vector3& position, const Vector3& direction,
                    size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return 0;
    }
    return m_binningData[ba].nextDirection(position, direction);
  }

  size_t bin(const Vector2& lposition, size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return 0;
    }
    return m_binningData[ba].searchLocal(lposition);
  }
  bool inside(const Vector3& position) const {
    const Vector3& bPosition = m_itransform * position;
    // loop and break
    for (auto& bData : m_binningData) {
      if (!(bData.inside(bPosition))) {
        return false;
      }
    }
    // survived all the checks
    return true;
  }

  bool inside(const Vector2& lposition) const {
    return true;
    std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
    for (; bdIter != m_binningData.end(); ++bdIter) {
      if (!(*bdIter).inside(lposition)) {
        return false;
      }
    }
    return true;
  }

  size_t dimensions() const { return m_binningData.size(); }

  size_t max(size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return 0;
    }
    return (m_binningData[ba].bins() - 1);
  }

  size_t bins(size_t ba) const {
    if (ba >= m_binningData.size()) {
      return 1;
    }
    return (m_binningData[ba].bins());
  }

  const Transform3& transform() const { return m_transform; }

  BinningValue binningValue(size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      throw "dimension out of bounds";
    }
    return (m_binningData[ba].binvalue);
  }

  size_t serialize(const std::array<size_t, 3>& bin) const {
    size_t serializedBin = bin[0];
    if (m_binningData.size() == 2) {
      serializedBin += bin[1] * m_binningData[0].bins();
    } else if (m_binningData.size() == 3) {
      serializedBin +=
          (bin[1] * m_binningData[0].bins() * bin[2] * m_binningData[1].bins());
    }
    return serializedBin;
  }

  std::ostream& toStream(std::ostream& sl,
                         const std::string& indent = "") const {
    sl << indent << "BinUtility for " << m_binningData.size()
       << "- dimensional array:" << std::endl;
    for (auto [ibd, bd] : enumerate(m_binningData)) {
      sl << indent << "dimension     : " << ibd << std::endl;
      sl << bd.toString(indent) << std::endl;
    }
    return sl;
  }

  std::string toString(const std::string& indent = "") const {
    std::stringstream ss;
    toStream(ss, indent);
    return ss.str();
  }

 private:
  std::vector<BinningData> m_binningData;  
  Transform3 m_transform;                  
  Transform3 m_itransform;                 
};

std::ostream& operator<<(std::ostream& sl, const BinUtility& bgen);

}  // namespace Acts