PD2HDChannelMapSPPluginBase.hpp

Go to the documentation of this file.

#pragma once
 
#include "PD2HDChannelMapSP.h"
#include "detchannelmaps/TPCChannelMap.hpp"
#include "logging/Logging.hpp" // NOLINT
 
namespace dunedaq {
namespace detchannelmaps {
 
class PD2HDChannelMapSPPluginBase : public TPCChannelMap
{
private:
  const uint m_det_id;
  std::unique_ptr<dune::PD2HDChannelMapSP> m_channel_map;
 
protected:
  std::function<uint(std::string)> m_elem_name_id_converter;
 
public:
  explicit PD2HDChannelMapSPPluginBase(uint det_id, const std::string& channel_map_path)
    : m_det_id(det_id)
  {
 
    const char* detchannelmaps_share_cstr = getenv("DETCHANNELMAPS_SHARE");
    if (!detchannelmaps_share_cstr) {
      throw std::runtime_error("Environment variable DETCHANNELMAPS_SHARE is not set");
    }
    std::string detchannelmaps_share(detchannelmaps_share_cstr);
    std::string channel_map_file = detchannelmaps_share + "/config/" + channel_map_path;
    m_channel_map.reset(new dune::PD2HDChannelMapSP());
    m_channel_map->ReadMapFromFile(channel_map_file);
  }
 
  PD2HDChannelMapSPPluginBase(const PD2HDChannelMapSPPluginBase&) =
    delete; 
  PD2HDChannelMapSPPluginBase& operator=(const PD2HDChannelMapSPPluginBase&) =
    delete; 
  PD2HDChannelMapSPPluginBase(PD2HDChannelMapSPPluginBase&&) =
    delete; 
  PD2HDChannelMapSPPluginBase& operator=(PD2HDChannelMapSPPluginBase&&) =
    delete; 

  uint get_offline_channel_from_det_crate_slot_stream_chan(uint det,
                                                           uint crate,
                                                           uint slot,
                                                           uint stream,
                                                           uint channel) final
  {
 
    // Must be a BDE channel
    if (det != m_det_id)
      return -1;
 
    // if stream number looks wrong (not 0,1,2,3 or 64,65,66,67)
    if ((stream & 0xbc))
      return -1;
 
    constexpr uint n_chan_per_stream = 64;
 
    uint link = (stream >> 6) & 1;
    uint stream_in_link = (stream & 0x3);
    uint wibframechan = n_chan_per_stream * stream_in_link + channel;
 
    auto chan_info = m_channel_map->GetChanInfoFromWIBElements(crate, slot, link, wibframechan);
 
    if (!chan_info.valid) {
      return -1;
    }
 
    return chan_info.offlchan;
  }

  uint get_plane_from_offline_channel(uint offchannel) final
  {
    auto chan_info = m_channel_map->GetChanInfoFromOfflChan(offchannel);
 
    if (!chan_info.valid) {
      return -1;
    }
 
    return chan_info.plane;
  };

  uint get_element_id_from_offline_channel(uint offchannel) final
  {
    auto chan_info = m_channel_map->GetChanInfoFromOfflChan(offchannel);
 
    if (!chan_info.valid) {
      return -1;
    }
 
    return m_elem_name_id_converter(chan_info.APAName);
 
    // There is only one element
    return 0;
  }

  std::string get_element_name_from_offline_channel(uint offchannel) final
  {
    auto chan_info = m_channel_map->GetChanInfoFromOfflChan(offchannel);
 
    if (!chan_info.valid) {
      return "";
    }
 
    return chan_info.APAName;
  }
 
  std::optional<TPCChannelMap::TPCChannelInfo> get_channel_info_from_offline_channel(uint offchannel) final
  {
    auto ci = m_channel_map->GetChanInfoFromOfflChan(offchannel);
 
    if (!ci.valid) {
      return std::nullopt;
    }
    constexpr uint n_chan_per_stream = 64;
    uint16_t slot_id = ci.wib - 1;
    uint16_t stream_id = ci.link * n_chan_per_stream + ci.wibframechan / n_chan_per_stream;
    uint16_t chan_id = ci.wibframechan % n_chan_per_stream;
 
    return TPCChannelMap::TPCChannelInfo{ m_det_id,  ci.crate, slot_id,
                                          stream_id, chan_id,  m_elem_name_id_converter(ci.APAName) };
  }
};
 
} // namespace detchannelmaps
} // namespace dunedaq