PDSChannelMap.hpp

Go to the documentation of this file.

#ifndef DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_PDSCHANNELMAP_HPP_
#define DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_PDSCHANNELMAP_HPP_
 
#include "cetlib/BasicPluginFactory.h"
#include "cetlib/compiler_macros.h"
#include "ers/Issue.hpp"
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
#include <optional>
 
#ifndef EXTERN_C_FUNC_DECLARE_START
// NOLINTNEXTLINE(build/define_used)
#define EXTERN_C_FUNC_DECLARE_START                                                                                    \
  extern "C"                                                                                                           \
  {
#endif
// NOLINTNEXTLINE(build/define_used)
#define DEFINE_DUNE_DET_PDSCHANNEL_MAP(klass)                                                                          \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::shared_ptr<dunedaq::detchannelmaps::PDSChannelMap> make()                                                       \
  {                                                                                                                    \
    return std::shared_ptr<dunedaq::detchannelmaps::PDSChannelMap>(new klass());                                       \
  }                                                                                                                    \
  }
 
namespace dunedaq {
 
// Disable coverage collection LCOV_EXCL_START
ERS_DECLARE_ISSUE(detchannelmaps,                                           
                  PDSChannelMapCreationFailed,                              
                  "Failed to create PDSChannelMap of type " << plugin_name, 
                  ((std::string)plugin_name)                                
)
ERS_DECLARE_ISSUE(detchannelmaps,                     
                  PDSInvalidStream,                   
                  "Invalid stream number " << stream, 
                  ((uint)stream)                      
)
 
namespace detchannelmaps {
 
class PDSChannelMap
{
public:
  struct PDSChannelInfo
  {
    static constexpr uint16_t kUndefined = 0xffff;
 
    uint16_t detector = kUndefined;
    uint16_t crate = kUndefined;
    uint16_t slot = kUndefined;
    uint16_t stream = kUndefined;
    uint16_t channel = kUndefined;
    uint16_t element = kUndefined;
  };

  virtual uint get_offline_channel_from_det_crate_slot_stream_chan(uint det,
                                                                   uint crate,
                                                                   uint slot,
                                                                   uint stream,
                                                                   uint channel) = 0;
 
  virtual uint get_element_from_offline_channel(uint) = 0;
  virtual std::string get_element_name_from_offline_channel(uint) = 0;
  virtual std::optional<PDSChannelInfo> get_det_crate_slot_fiber_chan_from_offline_channel(uint offchannel) = 0;
  virtual ~PDSChannelMap() noexcept = default;
 
protected:
  /*
   * @brief PDSChannelMap Constructor
   * @param name Name of the PDSChannelMap
   */
  explicit PDSChannelMap() {}
};

inline std::shared_ptr<PDSChannelMap>
make_pds_map(std::string const& plugin_name)
{
  static cet::BasicPluginFactory bpf("dunePDSChannelMap", "make");
 
  std::shared_ptr<PDSChannelMap> mod_ptr;
  try {
    mod_ptr = bpf.makePlugin<std::shared_ptr<PDSChannelMap>>(plugin_name);
  } catch (const cet::exception& cexpt) {
    throw PDSChannelMapCreationFailed(ERS_HERE, plugin_name, cexpt);
  }
  return mod_ptr;
}
 
} // namespace detchannelmaps
 
} // namespace dunedaq
 
#endif // DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_PDSCHANNELMAP_HPP_