DaphneApplication.cpp

Go to the documentation of this file.

 
#include "conffwk/Configuration.hpp"
#include "logging/Logging.hpp"
#include "oks/kernel.hpp"
 
#include "confmodel/DetectorStream.hpp"
#include "confmodel/GeoId.hpp"
#include "confmodel/NetworkInterface.hpp"
 
#include "ConfigObjectFactory.hpp"
#include "appmodel/DaphneApplication.hpp"
#include "appmodel/DaphneConf.hpp"
#include "appmodel/DaphneMapEntry.hpp"
#include "appmodel/DaphneV2ADC.hpp"
#include "appmodel/DaphneV2AFE.hpp"
#include "appmodel/DaphneV2BoardConf.hpp"
#include "appmodel/DaphneV2Channel.hpp"
#include "appmodel/DaphneV2ControllerModule.hpp"
#include "appmodel/DaphneV2LNA.hpp"
#include "appmodel/DaphneV2PGA.hpp"
#include "appmodel/DaphneV3ControllerModule.hpp"
#include "appmodel/FelixDataSender.hpp"
#include "appmodel/FelixDetectorToDaqConnection.hpp"
#include "appmodel/HermesDataSender.hpp"
#include "appmodel/HermesModule.hpp"
#include "appmodel/HermesModuleConf.hpp"
#include "appmodel/IpbusAddressTable.hpp"
#include "appmodel/NWDetDataReceiver.hpp"
#include "appmodel/NWDetDataSender.hpp"
#include "appmodel/NetworkDetectorToDaqConnection.hpp"
#include "appmodel/appmodelIssues.hpp"
 
#include <bitset>
#include <fmt/core.h>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
 
namespace dunedaq::appmodel {
 
std::vector<const confmodel::ExcludableEntity*>
DaphneApplication::contained_excludable_entities() const
{
  return to_resources(get_detector_connections());
}
 
void
DaphneApplication::generate_modules(std::shared_ptr<appmodel::ConfigurationHelper> helper) const
{
  ConfigObjectFactory obj_fac(this);
 
  std::vector<const confmodel::DaqModule*> modules;
 
  auto daphne_conf = get_configuration();
 
  std::map<std::string, const DaphneV2BoardConf*> conf_map;
  auto confs = daphne_conf->get_boards();
  for (const auto& c : confs) {
    conf_map[c->get_key()] = c->get_conf();
  }
 
  //  these maps are all indexed on the board id {detector].{crate}.{slot}
  std::map<std::string, bool> v3_map;
  std::map<std::string, const confmodel::NetworkInterface*> interfaces;
  std::map<std::string, std::string> ctrl_hosts;
 
  // map from ctrl_host to senders
  std::map<std::string, std::vector<const appmodel::HermesDataSender*>> hermes_senders;
 
  for (auto d2d_conn : get_detector_connections()) {
 
    // A ExcludableEntity can be disabled and still its application can be enabled because the application can have
    // multile resources, so we need to check which resources are enabled
    if (helper->is_excluded(d2d_conn)) {
      TLOG_DEBUG(7) << "Ignoring disabled DetectorToDaqConnection " << d2d_conn->UID();
      continue;
    }
 
    TLOG_DEBUG(6) << "Processing DetectorToDaqConnection " << d2d_conn->UID();
    // get the readout groups and the interfaces and streams therein; 1 reaout group corresponds to 1 data reader module
 
    // Redundant? Schema forbids 0 connections
    if (d2d_conn->contained_excludable_entities().empty()) {
      throw(BadConf(ERS_HERE, "DetectorToDaqConnection does not contain senders or receivers"));
    }
 
    auto flx_conn = dynamic_cast<const appmodel::FelixDetectorToDaqConnection*>(d2d_conn);   // NOLINT(runtime/rtti)
    auto net_conn = dynamic_cast<const appmodel::NetworkDetectorToDaqConnection*>(d2d_conn); // NOLINT(runtime/rtti)
 
    if (!net_conn && !flx_conn) {
      throw BadConf(ERS_HERE, d2d_conn->UID() + " is neither felix or eth connection");
    }
 
    if (flx_conn) {
      auto det_senders = flx_conn->get_felix_senders();
 
      // Loop over senders
      for (const auto* felix_sender : det_senders) {
 
        if (helper->is_excluded(felix_sender)) {
          TLOG() << "Skipping disabled sender: " << felix_sender->UID();
          continue;
        }
 
        auto ip = felix_sender->get_control_host();
 
        // from the felix sender we get the DetStream and then the GeoID
 
        auto streams = felix_sender->get_streams();
 
        for (const auto* det_s : streams) {
 
          if (helper->is_excluded(det_s)) {
            TLOG() << "Skipping disabled DetStream: " << det_s->UID();
            continue;
          }
 
          auto geo_id = det_s->get_geo_id();
          auto id = fmt::format("{}.{}.{}", geo_id->get_detector_id(), geo_id->get_crate_id(), geo_id->get_slot_id());
          if (!v3_map.contains(id)) {
            v3_map[id] = false;
          }
 
        } // loop over DetStreams
 
      } // loop over det_senders
    } // if flx connection
 
    if (net_conn) {
      auto det_senders = net_conn->get_net_senders();
 
      for (const auto* nw_sender : det_senders) {
        if (helper->is_excluded(nw_sender)) {
          TLOG() << "Skipping disabled sender: " << nw_sender->UID();
          continue;
        }
 
        // Check the sender type, must me a HermesSender
        const auto* hrms_sender = nw_sender->cast<appmodel::HermesDataSender>();
        if (!hrms_sender) {
          throw(BadConf(ERS_HERE, fmt::format("DataSender {} is not a appmodel::HermesDataSender", nw_sender->UID())));
        }
 
        hermes_senders[hrms_sender->get_control_host()].push_back(hrms_sender);
 
        auto streams = nw_sender->get_streams();
        for (const auto* det_s : streams) {
 
          if (helper->is_excluded(det_s)) {
            TLOG() << "Skipping disabled DetStream: " << det_s->UID();
            continue;
          }
 
          auto geo_id = det_s->get_geo_id();
          auto id = fmt::format("{}.{}.{}", geo_id->get_detector_id(), geo_id->get_crate_id(), geo_id->get_slot_id());
          if (!v3_map.contains(id)) {
            v3_map[id] = true;
            interfaces[id] = net_conn->get_net_receiver()->get_uses();
            ctrl_hosts[id] = hrms_sender->get_control_host();
          }
 
        } // loop over streams
 
      } // loop over NW senders
 
    } // if net_connection
 
  } // loop over det2DAQ Connections
 
  for (const auto& [id, v3] : v3_map) {
 
    auto conf_it = conf_map.find(id);
    if (conf_it == conf_map.end()) {
      throw MissingDaphne(ERS_HERE, id);
    }
    auto conf = conf_it->second;
 
    conffwk::ConfigObject module_obj =
      obj_fac.create((v3 ? "DaphneV3ControllerModule" : "DaphneV2ControllerModule"), fmt::format("controller-{}", id));
    module_obj.set_obj("daphne_conf", &daphne_conf->config_object());
    module_obj.set_obj("board_conf", &conf->config_object());
 
    auto module = obj_fac.get_dal<confmodel::DaqModule>(module_obj);
    modules.push_back(module);
 
    // Create Hermes Modules
    if (v3) {
      std::string hermes_uid = fmt::format("daphne-hermes-ctrl-{}", id);
      conffwk::ConfigObject hermes_obj = obj_fac.create("HermesModule", hermes_uid);
      hermes_obj.set_obj("address_table", &this->get_hermes_module_conf()->get_address_table()->config_object());
      hermes_obj.set_by_val<std::string>("uri",
                                         fmt::format("{}://{}:{}",
                                                     this->get_hermes_module_conf()->get_ipbus_type(),
                                                     ctrl_hosts[id],
                                                     this->get_hermes_module_conf()->get_ipbus_port()));
      hermes_obj.set_by_val<uint32_t>("timeout_ms", this->get_hermes_module_conf()->get_ipbus_timeout_ms()); // NOLINT
      hermes_obj.set_obj("destination", &interfaces[id]->config_object());
 
      std::vector<const conffwk::ConfigObject*> links_obj;
      const auto& senders = hermes_senders[ctrl_hosts[id]];
      for (const auto* sndr : senders) {
        links_obj.push_back(&sndr->config_object());
      }
      hermes_obj.set_objs("links", links_obj);
 
      modules.push_back(obj_fac.get_dal<appmodel::HermesModule>(hermes_obj));
    }
 
  } // ips
 
  obj_fac.update_modules(modules);
} // NOLINT
 
bool
DaphneV2BoardConf::is_channel_used(size_t ch) const
{
 
  for (auto ch_p : get_active_channels()) {
    if (ch_p->get_channel_id() == ch) {
      return true;
    }
  }
 
  return false;
}
 
const DaphneV2Channel&
DaphneV2BoardConf::get_channel(size_t ch) const
{
 
  for (auto ch_p : get_active_channels()) {
    if (ch_p->get_channel_id() == ch) {
      return *ch_p;
    }
  }
 
  return *get_default_channel();
}
 
bool
DaphneV2BoardConf::is_afe_used(size_t afe) const
{
 
  auto begin = afe * 8;
  auto end = (afe + 1) * 8;
  for (size_t i = begin; i < end; ++i) {
    if (is_channel_used(i))
      return true;
  }
 
  return false;
}
 
const DaphneV2AFE&
DaphneV2BoardConf::get_afe(size_t ch) const
{
 
  if (!is_afe_used(ch))
    return *get_default_afe();
 
  for (auto afe_p : get_active_afes()) {
    if (afe_p->get_afe_id() == ch) {
      return *afe_p;
    }
  }
 
  throw appmodel::MissingAFE(ERS_HERE, UID(), ch);
}
 
uint16_t
DaphneV2ADC::get_reg4() const
{
 
  // ADC, reg 4 has no parsing as it's all made of booleans
  std::bitset<5> reg4;
  // bits 0 and 2 are reserved
  reg4[1] = get_low_resolution();
  reg4[3] = get_output_offset_binary();
  reg4[4] = get_MSB_first();
  return reg4.to_ulong();
}
 
uint16_t
DaphneV2PGA::get_reg51() const
{
 
  std::bitset<14> reg51(get_lpf_cut_frequency());
  reg51 <<= 1;
  reg51[4] = get_integrator_disable();
  reg51[7] = true; // clamp is always disabled and we are in low noise mode
  reg51[13] = get_gain();
 
  return reg51.to_ulong();
}
 
uint16_t
DaphneV2LNA::get_reg52() const
{
 
  std::bitset<16> reg52;
 
  decltype(reg52) clamp(get_clamp());
  clamp <<= 6;
 
  reg52[12] = get_integrator_disable();
 
  decltype(reg52) gain(get_gain());
  clamp <<= 13;
 
  reg52 |= clamp;
  reg52 |= gain;
 
  return reg52.to_ulong();
}
 
} // namespace dunedaq::appmodel