TPCChannelMap.hpp

Go to the documentation of this file.

#ifndef DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_TPCCHANNELMAP_HPP_
#define DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_TPCCHANNELMAP_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_TPCCHANNEL_MAP(klass)                                                                          \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::shared_ptr<dunedaq::detchannelmaps::TPCChannelMap> make()                                                       \
  {                                                                                                                    \
    return std::shared_ptr<dunedaq::detchannelmaps::TPCChannelMap>(new klass());                                       \
  }                                                                                                                    \
  }
 
namespace dunedaq {
 
// Disable coverage collection LCOV_EXCL_START
ERS_DECLARE_ISSUE(detchannelmaps,                                           
                  ChannelMapCreationFailed,                                 
                  "Failed to create TPCChannelMap of type " << plugin_name, 
                  ((std::string)plugin_name)                                
)
 
ERS_DECLARE_ISSUE(detchannelmaps,                         
                  InvalidStreamID,                        
                  "Invalid stream identifier " << stream, 
                  ((uint)stream)                          
)
 
ERS_DECLARE_ISSUE(detchannelmaps,                           
                  InvalidDetectorID,                        
                  "Invalid detector identifier " << stream, 
                  ((uint)stream)                            
)
 
namespace detchannelmaps {
 
class TPCChannelMap
{
public:
  struct TPCChannelInfo
  {
    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_plane_from_offline_channel(uint offchannel) = 0;
  virtual uint get_element_id_from_offline_channel(uint) = 0;
  virtual std::string get_element_name_from_offline_channel(uint) = 0;
  virtual std::optional<TPCChannelInfo> get_channel_info_from_offline_channel(uint offchannel) = 0;
  virtual ~TPCChannelMap() noexcept = default;
 
protected:
  explicit TPCChannelMap() {}
};

inline std::shared_ptr<TPCChannelMap>
make_tpc_map(std::string const& plugin_name)
{
  static cet::BasicPluginFactory bpf("duneTPCChannelMap", "make");
 
  std::shared_ptr<TPCChannelMap> mod_ptr;
  try {
    mod_ptr = bpf.makePlugin<std::shared_ptr<TPCChannelMap>>(plugin_name);
  } catch (const cet::exception& cexpt) {
    throw ChannelMapCreationFailed(ERS_HERE, plugin_name, cexpt);
  }
  return mod_ptr;
}
 
} // namespace detchannelmaps
 
} // namespace dunedaq
 
#endif // DETCHANNELMAPS_INCLUDE_DETCHANNELMAPS_TPCCHANNELMAP_HPP_