move to detdataformats

CMakeLists.txt

@@ -12,13 +12,13 @@ daq_setup_environment()
 
 find_package(appfwk REQUIRED)
 find_package(logging REQUIRED)
-find_package(dataformats REQUIRED)
+find_package(detdataformats REQUIRED)
 find_package(readout REQUIRED)
 
 daq_codegen(sspcardreader.jsonnet TEMPLATES Structs.hpp.j2 Nljs.hpp.j2 )
 daq_codegen( *info.jsonnet DEP_PKGS opmonlib TEMPLATES opmonlib/InfoStructs.hpp.j2 opmonlib/InfoNljs.hpp.j2 )
 
-set(DUNEDAQ_DEPENDENCIES readout::readout dataformats::dataformats)
+set(DUNEDAQ_DEPENDENCIES appfwk::appfwk readout::readout detdataformats::detdataformats)
 
 # Provide override functionality for SSP dependencies
 #option(WITH_FTD2XX_AS_PACKAGE "SSP external (ftd2xx) as a dunedaq package" OFF)
@@ -37,7 +37,7 @@ set(DUNEDAQ_DEPENDENCIES readout::readout dataformats::dataformats)
 # Note that when the ers library is linked in, it uses a "::" because
 # it's in an external package, not a local CMake target. The semantics
 # are <namespace>::<shared library / executable>
-daq_add_library(anlBoard/*.cxx SSPCardWrapper.cpp LINK_LIBRARIES appfwk::appfwk ${SSP_DEPENDENCIES} ${DUNEDAQ_DEPENDENCIES})
+daq_add_library(anlBoard/*.cxx SSPCardWrapper.cpp LINK_LIBRARIES ${SSP_DEPENDENCIES} ${DUNEDAQ_DEPENDENCIES})
 #daq_add_library(IntPrinter.cpp LINK_LIBRARIES ers::ers)
 
 #if(WITH_FTD2XX_AS_PACKAGE)
@@ -51,7 +51,7 @@ daq_add_library(anlBoard/*.cxx SSPCardWrapper.cpp LINK_LIBRARIES appfwk::appfwk
 #daq_add_python_bindings(ssp_wrapper.cpp LINK_LIBRARIES ${PROJECT_NAME})
 
 ##############################################################################
-daq_add_plugin(SSPCardReader duneDAQModule LINK_LIBRARIES appfwk::appfwk sspmodules)
+daq_add_plugin(SSPCardReader duneDAQModule LINK_LIBRARIES sspmodules)
 
 ##############################################################################
 #daq_add_application( toylibrary_test_program toylibrary_test_program.cxx TEST LINK_LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY} toylibrary )

cmake/sspmodulesConfig.cmake.in

@@ -5,7 +5,7 @@ include(CMakeFindDependencyMacro)
 
 find_dependency(appfwk)
 find_dependency(logging)
-find_dependency(dataformats)
+find_dependency(detdataformats)
 find_dependency(readout)
 
 if (EXISTS ${CMAKE_SOURCE_DIR}/@PROJECT_NAME@)

src/SSPCardWrapper.cpp

@@ -65,7 +65,7 @@ SSPCardWrapper::init(const data_t& args)
   //          configuration parameters that you're looking for in args aren't available since the args you're
   //          getting here is likely only *::Init data from the json file
 
-  m_device_interface = new dunedaq::sspmodules::DeviceInterface(dunedaq::dataformats::ssp::kEthernet);
+  m_device_interface = new dunedaq::sspmodules::DeviceInterface(dunedaq::detdataformats::ssp::kEthernet);
   m_device_interface->Initialize(args);
 
   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPCardWrapper::init complete.";
@@ -491,7 +491,7 @@ SSPCardWrapper::process_ssp()
                     << ", calls to GetNext " << m_num_read_event_calls << ", of which returned null "
                     << m_num_zero_fragments << std::endl;
 
-      // std::size_t dataLength = millislice.size()-dunedaq::dataformats::MillisliceHeader::sizeInUInts;
+      // std::size_t dataLength = millislice.size()-dunedaq::detdataformats::MillisliceHeader::sizeInUInts;
 
       // SSPFragment::Metadata metadata;
       // metadata.sliceHeader=*((SSPDAQ::MillisliceHeader*)(void*)millislice.data());

src/SSPCardWrapper.hpp

@@ -10,7 +10,7 @@
 
 #include "sspmodules/sspcardreader/Nljs.hpp"
 
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 
 #include "SSPIssues.hpp"
 #include "anlBoard/DeviceInterface.hpp"

src/anlBoard/DeviceInterface.cxx

@@ -36,7 +36,7 @@ enum
 };
 
 // SSPDAQ::DeviceInterface::DeviceInterface(SSPDAQ::Comm_t commType, unsigned long deviceId)
-dunedaq::sspmodules::DeviceInterface::DeviceInterface(dunedaq::dataformats::ssp::Comm_t commType)
+dunedaq::sspmodules::DeviceInterface::DeviceInterface(dunedaq::detdataformats::ssp::Comm_t commType)
   : fCommType(commType)
   , fDeviceId(0)
   , fState(dunedaq::sspmodules::DeviceInterface::kUninitialized)
@@ -67,9 +67,9 @@ dunedaq::sspmodules::DeviceInterface::OpenSlowControl()
   dunedaq::sspmodules::Device* device = 0;
 
   TLOG_DEBUG(TLVL_WORK_STEPS) << "Opening "
-                              << ((fCommType == dunedaq::dataformats::ssp::kUSB)
+                              << ((fCommType == dunedaq::detdataformats::ssp::kUSB)
                                     ? "USB"
-                                    : ((fCommType == dunedaq::dataformats::ssp::kEthernet) ? "Ethernet" : "Emulated"))
+                                    : ((fCommType == dunedaq::detdataformats::ssp::kEthernet) ? "Ethernet" : "Emulated"))
                               << " device #" << fDeviceId << " for slow control only..." << std::endl;
 
   device = devman.OpenDevice(fCommType, fDeviceId, true);
@@ -509,7 +509,7 @@ dunedaq::sspmodules::DeviceInterface::BuildFragment(const dunedaq::sspmodules::T
 
   unsigned int dataSizeInWords = 0;
 
-  dataSizeInWords += dunedaq::dataformats::MillisliceHeader::sizeInUInts;
+  dataSizeInWords += dunedaq::detdataformats::MillisliceHeader::sizeInUInts;
   for (auto ev = eventsToWrite.begin(); ev != eventsToWrite.end(); ++ev) {
     dataSizeInWords += (*ev)->header.length;
   }
@@ -518,7 +518,7 @@ dunedaq::sspmodules::DeviceInterface::BuildFragment(const dunedaq::sspmodules::T
   // Build slice header//
   //==================//
 
-  dunedaq::dataformats::MillisliceHeader sliceHeader;
+  dunedaq::detdataformats::MillisliceHeader sliceHeader;
   sliceHeader.length = dataSizeInWords;
   sliceHeader.nTriggers = eventsToWrite.size();
   sliceHeader.startTime = theTrigger.startTime;
@@ -533,16 +533,16 @@ dunedaq::sspmodules::DeviceInterface::BuildFragment(const dunedaq::sspmodules::T
   fragmentData.resize(dataSizeInWords);
 
   static unsigned int headerSizeInWords =
-    sizeof(dunedaq::dataformats::EventHeader) / sizeof(unsigned int); // Size of DAQ event header
+    sizeof(dunedaq::detdataformats::EventHeader) / sizeof(unsigned int); // Size of DAQ event header
 
   // Put millislice header at front of vector
   auto sliceDataPtr = fragmentData.begin();
   unsigned int* millisliceHeaderPtr = static_cast<unsigned int*>(static_cast<void*>(&sliceHeader));
   std::copy(
-    millisliceHeaderPtr, millisliceHeaderPtr + dunedaq::dataformats::MillisliceHeader::sizeInUInts, sliceDataPtr);
+    millisliceHeaderPtr, millisliceHeaderPtr + dunedaq::detdataformats::MillisliceHeader::sizeInUInts, sliceDataPtr);
 
   // Fill rest of vector with event data
-  sliceDataPtr += dunedaq::dataformats::MillisliceHeader::sizeInUInts;
+  sliceDataPtr += dunedaq::detdataformats::MillisliceHeader::sizeInUInts;
 
   for (auto ev = eventsToWrite.begin(); ev != eventsToWrite.end(); ++ev) {
     // DAQ event header
@@ -667,7 +667,7 @@ dunedaq::sspmodules::DeviceInterface::ReadEventFromDevice(EventPacket& event)
   unsigned int* headerBlock = (unsigned int*)&event.header;
   headerBlock[0] = 0xAAAAAAAA;
 
-  static const unsigned int headerReadSize = (sizeof(dunedaq::dataformats::EventHeader) / sizeof(unsigned int) - 1);
+  static const unsigned int headerReadSize = (sizeof(dunedaq::detdataformats::EventHeader) / sizeof(unsigned int) - 1);
 
   // Wait for hardware queue to fill with full header data
   unsigned int timeWaited = 0; // in us
@@ -705,7 +705,7 @@ dunedaq::sspmodules::DeviceInterface::ReadEventFromDevice(EventPacket& event)
   std::copy(data.begin(), data.end(), &(headerBlock[1]));
 
   // Wait for hardware queue to fill with full event data
-  unsigned int bodyReadSize = event.header.length - (sizeof(dunedaq::dataformats::EventHeader) / sizeof(unsigned int));
+  unsigned int bodyReadSize = event.header.length - (sizeof(dunedaq::detdataformats::EventHeader) / sizeof(unsigned int));
   queueLengthInUInts = 0;
   timeWaited = 0; // in us
 
@@ -740,7 +740,7 @@ dunedaq::sspmodules::DeviceInterface::ReadEventFromDevice(EventPacket& event)
   // Copy event data into event packet
   event.data = std::move(data);
 
-  auto ehsize = sizeof(struct dunedaq::dataformats::EventHeader);
+  auto ehsize = sizeof(struct dunedaq::detdataformats::EventHeader);
   auto ehlength = event.header.length;
   TLOG_DEBUG(TLVL_WORK_STEPS) << "Event data size: " << event.data.size() << " ehsize: " << ehsize
                               << " ehl: " << ehlength;
@@ -887,17 +887,17 @@ dunedaq::sspmodules::DeviceInterface::Configure(const nlohmann::json& args)
   }
 
   auto m_cfg = args.get<dunedaq::sspmodules::sspcardreader::Conf>();
-  int interfaceTypeCode = m_cfg.interface_type; // dunedaq::dataformats::kEthernet;
+  int interfaceTypeCode = m_cfg.interface_type; // dunedaq::detdataformats::kEthernet;
   std::stringstream ss;
   switch (interfaceTypeCode) {
     case 0:
-      fCommType = dunedaq::dataformats::ssp::kUSB;
+      fCommType = dunedaq::detdataformats::ssp::kUSB;
       break;
     case 1:
-      fCommType = dunedaq::dataformats::ssp::kEthernet;
+      fCommType = dunedaq::detdataformats::ssp::kEthernet;
       break;
     case 2:
-      fCommType = dunedaq::dataformats::ssp::kEmulated;
+      fCommType = dunedaq::detdataformats::ssp::kEmulated;
       break;
     case 999:
       ss << "Error: Invalid interface type set (" << interfaceTypeCode << ")!" << std::endl;
@@ -909,7 +909,7 @@ dunedaq::sspmodules::DeviceInterface::Configure(const nlohmann::json& args)
       throw ConfigurationError(ERS_HERE, ss.str());
   }
   //
-  if (fCommType != dunedaq::dataformats::ssp::kEthernet) {
+  if (fCommType != dunedaq::detdataformats::ssp::kEthernet) {
     fDeviceId = 0;
     std::stringstream ss;
     ss << "Error: Non-functioning interface type set: " << fCommType
@@ -926,9 +926,9 @@ dunedaq::sspmodules::DeviceInterface::Configure(const nlohmann::json& args)
   dunedaq::sspmodules::Device* device = 0;
 
   TLOG_DEBUG(TLVL_WORK_STEPS) << "Configuring "
-                              << ((fCommType == dunedaq::dataformats::ssp::kUSB)
+                              << ((fCommType == dunedaq::detdataformats::ssp::kUSB)
                                     ? "USB"
-                                    : ((fCommType == dunedaq::dataformats::ssp::kEthernet) ? "Ethernet" : "Emulated"))
+                                    : ((fCommType == dunedaq::detdataformats::ssp::kEthernet) ? "Ethernet" : "Emulated"))
                               << " device #" << fDeviceId << "..." << std::endl;
 
   device = devman.OpenDevice(fCommType, fDeviceId);
@@ -1227,17 +1227,17 @@ dunedaq::sspmodules::DeviceInterface::GetIdentifier()
 
   std::string ident;
   ident += "SSP@";
-  if (fCommType == dunedaq::dataformats::ssp::kUSB) {
+  if (fCommType == dunedaq::detdataformats::ssp::kUSB) {
     ident += "(USB";
     ident += fDeviceId;
     ident += "):";
-  } else if (fCommType == dunedaq::dataformats::ssp::kEthernet) {
+  } else if (fCommType == dunedaq::detdataformats::ssp::kEthernet) {
     boost::asio::ip::address ip = boost::asio::ip::address_v4(fDeviceId);
     std::string ipString = ip.to_string();
     ident += "(";
     ident += ipString;
     ident += "):";
-  } else if (fCommType == dunedaq::dataformats::ssp::kEmulated) {
+  } else if (fCommType == dunedaq::detdataformats::ssp::kEmulated) {
     ident += "(EMULATED";
     ident += fDeviceId;
     ident += "):";
@@ -1246,7 +1246,7 @@ dunedaq::sspmodules::DeviceInterface::GetIdentifier()
 }
 
 unsigned long                   // NOLINT(runtime/int)
-dunedaq::sspmodules::DeviceInterface::GetTimestamp(const dunedaq::dataformats::EventHeader& header)
+dunedaq::sspmodules::DeviceInterface::GetTimestamp(const dunedaq::detdataformats::EventHeader& header)
 {
   unsigned long packetTime = 0; // NOLINT(runtime/int)
   TLOG_DEBUG(TLVL_WORK_STEPS) << "fUseExternalTimestamp value: " << std::boolalpha << fUseExternalTimestamp

src/anlBoard/DeviceInterface.hpp

@@ -10,7 +10,7 @@
 
 #include "appfwk/app/Nljs.hpp"
 #include "readout/ReadoutTypes.hpp"
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 #include "logging/Logging.hpp"
 
 #include "DeviceManager.hpp"
@@ -48,7 +48,7 @@ class DeviceInterface{
 
   //Just sets the fields needed to request the device.
   //Real work is done in Initialize which is called manually.
-  explicit DeviceInterface(dunedaq::dataformats::ssp::Comm_t commType);
+  explicit DeviceInterface(dunedaq::detdataformats::ssp::Comm_t commType);
 
   ~DeviceInterface(){
     //if(fRequestReceiver){
@@ -174,7 +174,7 @@ class DeviceInterface{
   Device* fDevice;
 
   //Whether we are using USB or Ethernet to connect to the device
-  dunedaq::dataformats::ssp::Comm_t fCommType;
+  dunedaq::detdataformats::ssp::Comm_t fCommType;
 
   //Index of the device in the hardware-returned list
   unsigned long fDeviceId;    // NOLINT(runtime/int)
@@ -189,7 +189,7 @@ class DeviceInterface{
 
   bool GetTriggerInfo(const EventPacket& event,dunedaq::sspmodules::TriggerInfo& newTrigger);
 
-  unsigned long GetTimestamp(const dunedaq::dataformats::EventHeader& header);  // NOLINT(runtime/int)
+  unsigned long GetTimestamp(const dunedaq::detdataformats::EventHeader& header);  // NOLINT(runtime/int)
 
   //Build a millislice containing only a header and place in fQueue
   //    void BuildEmptyMillislice(unsigned long startTime,unsigned long endTime);

src/anlBoard/DeviceManager.cxx

@@ -8,7 +8,7 @@
 #ifndef SSPMODULES_SRC_ANLBOARD_DEVICEMANAGER_CXX_
 #define SSPMODULES_SRC_ANLBOARD_DEVICEMANAGER_CXX_
 
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 
 #include "DeviceManager.hpp"
 //#include "ftd2xx.h"
@@ -175,12 +175,12 @@ dunedaq::sspmodules::DeviceManager::RefreshDevices()
 }
 
 dunedaq::sspmodules::Device*
-dunedaq::sspmodules::DeviceManager::OpenDevice(dunedaq::dataformats::ssp::Comm_t commType,
+dunedaq::sspmodules::DeviceManager::OpenDevice(dunedaq::detdataformats::ssp::Comm_t commType,
                                                unsigned int deviceNum,
                                                bool slowControlOnly)
 {
   // Check for devices if this hasn't yet been done
-  if (!fHaveLookedForDevices && commType != dunedaq::dataformats::ssp::kEmulated) {
+  if (!fHaveLookedForDevices && commType != dunedaq::detdataformats::ssp::kEmulated) {
     this->RefreshDevices();
   }
 
@@ -200,7 +200,7 @@ dunedaq::sspmodules::DeviceManager::OpenDevice(dunedaq::dataformats::ssp::Comm_t
       //    }
       //    break;
       //
-    case dunedaq::dataformats::ssp::kEthernet:
+    case dunedaq::detdataformats::ssp::kEthernet:
       if (fEthernetDevices.find(deviceNum) == fEthernetDevices.end()) {
         fEthernetDevices[deviceNum] = (std::move(
           std::unique_ptr<dunedaq::sspmodules::EthernetDevice>(new dunedaq::sspmodules::EthernetDevice(deviceNum))));
@@ -214,7 +214,7 @@ dunedaq::sspmodules::DeviceManager::OpenDevice(dunedaq::dataformats::ssp::Comm_t
       }
       break;
 
-    case dunedaq::dataformats::ssp::kEmulated:
+    case dunedaq::detdataformats::ssp::kEmulated:
       while (fEmulatedDevices.size() <= deviceNum) {
         fEmulatedDevices.push_back(std::move(std::unique_ptr<dunedaq::sspmodules::EmulatedDevice>(
           new dunedaq::sspmodules::EmulatedDevice(fEmulatedDevices.size()))));

src/anlBoard/DeviceManager.hpp

@@ -8,7 +8,7 @@
 #ifndef SSPMODULES_SRC_ANLBOARD_DEVICEMANAGER_HPP_
 #define SSPMODULES_SRC_ANLBOARD_DEVICEMANAGER_HPP_
 
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 
 //#include "ftd2xx.h"
 //#include "USBDevice.h"
@@ -39,7 +39,7 @@ class DeviceManager{
   //unsigned int GetNUSBDevices();
 
   //Open a device and return a pointer containing a handle to it
-  Device* OpenDevice(dunedaq::dataformats::ssp::Comm_t commType,unsigned int deviceId,bool slowControlOnly=false);
+  Device* OpenDevice(dunedaq::detdataformats::ssp::Comm_t commType,unsigned int deviceId,bool slowControlOnly=false);
 
   //Interrogate FTDI for list of devices. GetNUSBDevices and OpenDevice will call this
   //if it has not yet been run, so it should not normally be necessary to call this directly.

src/anlBoard/EmulatedDevice.cxx

@@ -8,7 +8,7 @@
 #ifndef SSPMODULES_SRC_ANLBOARD_EMULATEDDEVICE_CXX_
 #define SSPMODULES_SRC_ANLBOARD_EMULATEDDEVICE_CXX_
 
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 
 #include "anlExceptions.hpp"
 #include "EmulatedDevice.hpp"
@@ -151,7 +151,7 @@ void dunedaq::sspmodules::EmulatedDevice::Stop(){
 void dunedaq::sspmodules::EmulatedDevice::EmulatorLoop(){
 
   //dune::DAQLogger::LogDebug("SSP_EmulatedDevice")<<"Starting emulator loop..."<<std::endl;
-  static unsigned int headerSizeInWords=sizeof(dunedaq::dataformats::EventHeader)/sizeof(unsigned int);
+  static unsigned int headerSizeInWords=sizeof(dunedaq::detdataformats::EventHeader)/sizeof(unsigned int);
 
   //We want to generate events on random channels at random times
   std::default_random_engine generator;
@@ -171,7 +171,7 @@ void dunedaq::sspmodules::EmulatedDevice::EmulatorLoop(){
     int channel = channelDistribution(generator);
 
     //Build an event header. 
-    dunedaq::dataformats::EventHeader header;
+    dunedaq::detdataformats::EventHeader header;
 
     //Standard header word
     header.header=0xAAAAAAAA;

src/anlBoard/EmulatedDevice.hpp

@@ -8,7 +8,7 @@
 #ifndef SSPMODULES_SRC_ANLBOARD_EMULATEDDEVICE_HPP_
 #define SSPMODULES_SRC_ANLBOARD_EMULATEDDEVICE_HPP_
 
-#include "dataformats/ssp/SSPTypes.hpp"
+#include "detdataformats/ssp/SSPTypes.hpp"
 
 #include "Device.hpp"
 #include "SafeQueue.hpp"