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/Utilities/BinningData.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Definitions.hpp"

#include <array>
#include <iostream>
#include <memory>
#include <vector>

namespace Acts {

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

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

  BinUtility(const BinningData& bData,
             const Transform3D& tForm = Transform3D::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 Transform3D& tForm = Transform3D::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 Transform3D& tForm = Transform3D::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)
      : m_binningData(sbu.m_binningData),
        m_transform(sbu.m_transform),
        m_itransform(sbu.m_itransform) {}

  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+=(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;

  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 Vector3D& position) const {
    const Vector3D 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 Vector3D& 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;
  }

  std::vector<size_t> neighbourRange(const Vector3D& position,
                                     size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return {0};
    }
    std::vector<size_t> neighbourRange;
    size_t cbin = bin(position, ba);
    size_t pbin = cbin;
    size_t nbin = cbin;
    if (m_binningData[ba].decrement(pbin)) {
      neighbourRange.push_back(pbin);
    }
    neighbourRange.push_back(cbin);
    if (m_binningData[ba].increment(nbin) && nbin != pbin) {
      neighbourRange.push_back(nbin);
    }
    return neighbourRange;
  }

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

  size_t bin(const Vector2D& lposition, size_t ba = 0) const {
    if (ba >= m_binningData.size()) {
      return 0;
    }
    return m_binningData[ba].searchLocal(lposition);
  }
  bool inside(const Vector3D& position) const {
    const Vector3D& 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 Vector2D& 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 Transform3D& 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 {
    sl << "BinUtility for " << m_binningData.size()
       << "- dimensional array:" << std::endl;
    std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
    for (size_t ibd = 0; bdIter != m_binningData.end(); ++bdIter, ++ibd) {
      sl << "dimension     : " << ibd << std::endl;
      sl << " - type       : " << size_t((*bdIter).type) << std::endl;
      sl << " - option     : " << size_t((*bdIter).option) << std::endl;
      sl << " - value      : " << size_t((*bdIter).binvalue) << std::endl;
      sl << " - bins       : " << (*bdIter).bins() << std::endl;
      sl << " - min/max    : " << (*bdIter).min << " / " << (*bdIter).max
         << std::endl;
      if ((*bdIter).type == equidistant) {
        sl << " - step       : " << (*bdIter).step << std::endl;
      }
      sl << " - boundaries : | ";
      std::vector<float>::const_iterator bIter = (*bdIter).boundaries().begin();
      for (; bIter != (*bdIter).boundaries().end(); ++bIter) {
        sl << (*bIter) << " | ";
      }
      sl << std::endl;
    }
    return sl;
  }

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

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

}  // namespace Acts