CathodeSegmentation.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_MCH_MAPPING_CATHODESEGMENTATION_H
#define O2_MCH_MAPPING_CATHODESEGMENTATION_H
 
#include "CathodeSegmentationCInterface.h"
#include <stdexcept>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <functional>
#include <iomanip>
 
namespace o2
{
namespace mch
{
namespace mapping
{
 
 
class CathodeSegmentation
{
 public:
  CathodeSegmentation(int detElemId, bool isBendingPlane)
    : mImpl{nullptr},
      mDualSampaIds{},
      mDetElemId{detElemId},
      mIsBendingPlane{isBendingPlane}
  {
    if (&mchCathodeSegmentationConstruct == nullptr) {
      throw std::runtime_error("no mch mapping implementaion found : did you forget to link with an actual implementation library (e.g. O2MCHMappingImpl4) ? ");
    }
    mImpl = mchCathodeSegmentationConstruct(detElemId, isBendingPlane);
    if (!mImpl) {
      throw std::runtime_error("Can not create segmentation for DE " + std::to_string(detElemId) +
                               (mIsBendingPlane ? " Bending" : " NonBending"));
    }
    std::vector<int> dpid;
    auto addDualSampaId = [&dpid](int dualSampaId) { dpid.push_back(dualSampaId); };
    auto callback = [](void* data, int dualSampaId) {
      auto fn = static_cast<decltype(&addDualSampaId)>(data);
      (*fn)(dualSampaId);
    };
    mchCathodeSegmentationForEachDualSampa(mImpl, callback, &addDualSampaId);
    mDualSampaIds = dpid;
    int n{0};
    for (auto i = 0; i < nofDualSampas(); ++i) {
      forEachPadInDualSampa(dualSampaId(i), [&n](int /*catPadIndex*/) { ++n; });
    }
    mNofPads = n;
  }
 
  bool operator==(const CathodeSegmentation& rhs) const
  {
    return mDetElemId == rhs.mDetElemId && mIsBendingPlane == rhs.mIsBendingPlane;
  }
 
  bool operator!=(const CathodeSegmentation& rhs) const { return !(rhs == *this); }
 
  friend void swap(CathodeSegmentation& a, CathodeSegmentation& b)
  {
    using std::swap;
 
    swap(a.mImpl, b.mImpl);
    swap(a.mDualSampaIds, b.mDualSampaIds);
    swap(a.mDetElemId, b.mDetElemId);
    swap(a.mIsBendingPlane, b.mIsBendingPlane);
    swap(a.mNofPads, b.mNofPads);
  }
 
  CathodeSegmentation(const CathodeSegmentation& seg)
  {
    mDetElemId = seg.mDetElemId;
    mIsBendingPlane = seg.mIsBendingPlane;
    mImpl = mchCathodeSegmentationConstruct(mDetElemId, mIsBendingPlane);
    mDualSampaIds = seg.mDualSampaIds;
    mNofPads = seg.mNofPads;
  }
 
  CathodeSegmentation& operator=(CathodeSegmentation seg)
  {
    swap(*this, seg);
    return *this;
  }
 
  ~CathodeSegmentation() { mchCathodeSegmentationDestruct(mImpl); }
 
  bool isValid(int catPadIndex) const { return mchCathodeSegmentationIsPadValid(mImpl, catPadIndex) > 0; }
 
 
  int findPadByPosition(double x, double y) const { return mchCathodeSegmentationFindPadByPosition(mImpl, x, y); }
 
  int findPadByFEE(int dualSampaId, int dualSampaChannel) const
  {
    if (dualSampaChannel < 0 || dualSampaChannel > 63) {
      throw std::out_of_range("dualSampaChannel should be between 0 and 63");
    }
    return mchCathodeSegmentationFindPadByFEE(mImpl, dualSampaId, dualSampaChannel);
  }
 
  double padPositionX(int catPadIndex) const { return mchCathodeSegmentationPadPositionX(mImpl, catPadIndex); }
  double padPositionY(int catPadIndex) const { return mchCathodeSegmentationPadPositionY(mImpl, catPadIndex); }
  double padSizeX(int catPadIndex) const { return mchCathodeSegmentationPadSizeX(mImpl, catPadIndex); }
  double padSizeY(int catPadIndex) const { return mchCathodeSegmentationPadSizeY(mImpl, catPadIndex); }
  int padDualSampaId(int catPadIndex) const { return mchCathodeSegmentationPadDualSampaId(mImpl, catPadIndex); }
  int padDualSampaChannel(int catPadIndex) const { return mchCathodeSegmentationPadDualSampaChannel(mImpl, catPadIndex); }
  std::string padAsString(int catPadIndex) const;
 
  bool isBendingPlane() const { return mIsBendingPlane; }
  int nofDualSampas() const { return mDualSampaIds.size(); }
  int nofPads() const { return mNofPads; }
  int dualSampaId(int dualSampaIndex) const { return mDualSampaIds[dualSampaIndex]; }
 
  void forEachDualSampa(std::function<void(int dualSampaId)> func) const;
 
  template <typename CALLABLE>
  void forEachPadInDualSampa(int dualSampaId, CALLABLE&& func) const;
 
  template <typename CALLABLE>
  void forEachPadInArea(double xmin, double ymin, double xmax, double ymax, CALLABLE&& func) const;
 
  template <typename CALLABLE>
  void forEachPad(CALLABLE&& func) const;
 
  template <typename CALLABLE>
  void forEachNeighbouringPad(int catPadIndex, CALLABLE&& func) const;
 private:
  MchCathodeSegmentationHandle mImpl;
  std::vector<int> mDualSampaIds;
  int mDetElemId;
  bool mIsBendingPlane;
  int mNofPads = 0;
};
 
template <typename CALLABLE>
void CathodeSegmentation::forEachPadInDualSampa(int dualSampaId, CALLABLE&& func) const
{
  auto callback = [](void* data, int catPadIndex) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(catPadIndex);
  };
  mchCathodeSegmentationForEachPadInDualSampa(mImpl, dualSampaId, callback, &func);
}
 
template <typename CALLABLE>
void CathodeSegmentation::forEachPadInArea(double xmin, double ymin, double xmax, double ymax, CALLABLE&& func) const
{
  auto callback = [](void* data, int catPadIndex) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(catPadIndex);
  };
  mchCathodeSegmentationForEachPadInArea(mImpl, xmin, ymin, xmax, ymax, callback, &func);
}
 
template <typename CALLABLE>
void CathodeSegmentation::forEachPad(CALLABLE&& func) const
{
  for (auto i = 0; i < nofPads(); i++) {
    func(i);
  }
}
 
template <typename CALLABLE>
void CathodeSegmentation::forEachNeighbouringPad(int catPadIndex, CALLABLE&& func) const
{
  auto callback = [](void* data, int puid) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(puid);
  };
  mchCathodeSegmentationForEachNeighbouringPad(mImpl, catPadIndex, callback, &func);
}
 
inline void CathodeSegmentation::forEachDualSampa(std::function<void(int dualSampaId)> func) const
{
  auto callback = [](void* data, int dualSampaId) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(dualSampaId);
  };
  mchCathodeSegmentationForEachDualSampa(mImpl, callback, &func);
}
 
template <typename CALLABLE>
void forEachDetectionElement(CALLABLE&& func)
{
  auto callback = [](void* data, int detElemId) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(detElemId);
  };
  mchCathodeSegmentationForEachDetectionElement(callback, &func);
}
 
template <typename CALLABLE>
void forOneDetectionElementOfEachSegmentationType(CALLABLE&& func)
{
  auto callback = [](void* data, int detElemId) {
    auto fn = static_cast<decltype(&func)>(data);
    (*fn)(detElemId);
  };
  mchCathodeSegmentationForOneDetectionElementOfEachSegmentationType(callback, &func);
}
 
inline std::string CathodeSegmentation::padAsString(int catPadIndex) const
{
  if (!isValid(catPadIndex)) {
    return "invalid pad with uid=" + std::to_string(catPadIndex);
  }
  std::stringstream s;
 
  s << "FEC " << std::setw(4) << padDualSampaId(catPadIndex)
    << "CH " << std::setw(2) << padDualSampaChannel(catPadIndex)
    << "X " << std::setw(7) << std::setprecision(2) << padPositionX(catPadIndex)
    << "Y " << std::setw(7) << std::setprecision(2) << padPositionY(catPadIndex)
    << "SX " << std::setw(7) << std::setprecision(2) << padSizeX(catPadIndex)
    << "SY " << std::setw(7) << std::setprecision(2) << padSizeY(catPadIndex);
 
  return s.str();
}
 
} // namespace mapping
} // namespace mch
} // namespace o2
#endif