tapipe.cxx File Reference

#include "CLI/App.hpp"
#include "CLI/Config.hpp"
#include "CLI/Formatter.hpp"
#include <fmt/core.h>
#include <fmt/format.h>
#include "hdf5libs/HDF5RawDataFile.hpp"
#include "trgdataformats/TriggerPrimitive.hpp"
#include "triggeralgs/HorizontalMuon/TAMakerHorizontalMuonAlgorithm.hpp"
#include "triggeralgs/TriggerObjectOverlay.hpp"

Include dependency graph for tapipe.cxx:

Go to the source code of this file.

Classes
class	HDF5FileReader
struct	fmt::formatter< dunedaq::daqdataformats::SourceID >
struct	fmt::formatter< hdf5libs::HDF5RawDataFile::record_id_t >

Functions
int	main (int argc, char *argv[])

Detailed Description

Developer(s) of this DAQ application have yet to replace this line with a brief description of the application.

This is part of the DUNE DAQ Application Framework, copyright 2020. Licensing/copyright details are in the COPYING file that you should have received with this code.

Definition in file tapipe.cxx.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 119 of file tapipe.cxx.

{
  std::string input_file;
  bool verbose = false;
  CLI::App app{ "tapipe" };
  // argv = app.ensure_utf8(argv);
 
  app.add_option("-i", input_file, "Input TPStream file path")->required();
  app.add_flag("-v", verbose);
  CLI11_PARSE(app, argc, argv);
 
  fmt::print("TPStream file: {}\n", input_file);
 
  // Pointer to DD hdf5 file
  std::unique_ptr<hdf5libs::HDF5RawDataFile> tpstream_file;
 
  try {
    tpstream_file = std::make_unique<hdf5libs::HDF5RawDataFile>(input_file);
  } catch (const hdf5libs::FileOpenFailed& e) {
    std::cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ERROR <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;
    std::cerr << e.what() << '\n';
    exit(-1);
  }
 
  fmt::print("{} opened\n", input_file);
 
  // Check the record type
  fmt::print("  File type: {}\n", tpstream_file->get_record_type());
 
  // Extract the list of timeslices in the file
  auto records = tpstream_file->get_all_record_ids();
  std::set<daqdataformats::SourceID> source_ids;
  // Find what Source IDs are available in the file (all records)
  for (const auto& rid : records) {
    const auto& [id, slice] = rid;
    auto sids = tpstream_file->get_source_ids(rid);
    source_ids.merge(sids);
    if (verbose)
      fmt::print("TR {}:{} [{}]\n", id, slice, fmt::join(sids, ", "));
  }
  fmt::print("Source IDs [{}]\n", fmt::join(source_ids, ", "));
 
  // Map of source ids to trigger records
  std::map<daqdataformats::SourceID, hdf5libs::HDF5RawDataFile::record_id_set> m;
  for (const auto& sid : source_ids) {
    for (const auto& rid : records) {
      auto rec_sids = tpstream_file->get_source_ids(rid);
      if (rec_sids.find(sid) != rec_sids.end()) {
        m[sid].insert(rid);
      }
    }
    if (verbose)
      fmt::print("Record IDs for {} : [{}]\n", sid, fmt::join(m[sid], ", "));
  }
 
  // Print the number of timeslices in the files
  fmt::print("  Number of time slices in file: {}\n", records.size());
 
  // Get the list of records containing the tp writer source id
  // I know the nuber by spying into the TP Stream File
  daqdataformats::SourceID tp_writer_sid{ daqdataformats::SourceID::Subsystem::kTrigger, 0 };
  auto tp_records = m[tp_writer_sid];
 
  // Prepare the TP buffer
  std::vector<trgdataformats::TriggerPrimitive> tp_buffer;
 
  auto a_slice_id = *tp_records.begin();
  fmt::print("Processing tp time slice {}\n", a_slice_id);
 
  // auto tsl_hdr = tsl.get_header();
  auto tsl_hdr = tpstream_file->get_tsh_ptr(a_slice_id);
 
  // Print header ingo
  fmt::print("  Run number: {}\n", tsl_hdr->run_number);
  fmt::print("  TSL number: {}\n", tsl_hdr->timeslice_number);
 
  auto frag = tpstream_file->get_frag_ptr(a_slice_id, tp_writer_sid);
 
  fmt::print("  Fragment id: {} [{}]\n",
             frag->get_element_id().to_string(),
             daqdataformats::fragment_type_to_string(frag->get_fragment_type()));
 
  size_t n_tps = frag->get_data_size() / sizeof(trgdataformats::TriggerPrimitive);
  fmt::print("TP fragment size: {}\n", frag->get_data_size());
  fmt::print("Num TPs: {}\n", n_tps);
 
  trgdataformats::TriggerPrimitive* tp_array = static_cast<trgdataformats::TriggerPrimitive*>(frag->get_data());
 
  // Prepare the TP buffer, checking for time ordering
  tp_buffer.resize(tp_buffer.size() + n_tps);
 
  uint64_t last_ts = 0;
  for (size_t i(0); i < n_tps; ++i) {
    auto& tp = tp_array[i];
    if (tp.time_start <= last_ts) {
      fmt::print("ERROR: {} {} ", +tp.time_start, last_ts);
    }
    tp_buffer.push_back(tp);
  }
 
  // Print some useful info
  uint64_t d_ts = tp_array[n_tps - 1].time_start - tp_array[0].time_start;
  fmt::print("TS gap: {} {} ms\n", d_ts, d_ts * 16.0 / 1'000'000);
 
  // Finally create a TA maker
  // Waiting for A.Oranday's factory!
  triggeralgs::TAMakerHorizontalMuonAlgorithm hmta;
 
  // Create output buffer
  std::vector<triggeralgs::TriggerActivity> ta_buffer;
 
  // We should config the algo, really
  const nlohmann::json config = {};
  hmta.configure(config);
 
  // Loop over TPs
  for (const auto& tp : tp_buffer) {
    hmta(tp, ta_buffer);
  }
 
  // Count number of TAs generated
  fmt::print("ta_buffer.size() = {}\n", ta_buffer.size());
 
  size_t payload_size(0);
  for (const auto& ta : ta_buffer) {
    payload_size += triggeralgs::get_overlay_nbytes(ta);
  }
 
  // Count number of TAs generated
  fmt::print("ta_buffer in bytes = {}\n", payload_size);
 
  char* payload = static_cast<char*>(malloc(payload_size));
 
  size_t offset(0);
  for (const auto& ta : ta_buffer) {
    triggeralgs::write_overlay(ta, static_cast<void*>(payload + offset));
    offset += triggeralgs::get_overlay_nbytes(ta);
  }
 
  daqdataformats::Fragment ta_frag(static_cast<void*>(payload), payload_size);
 
  free(static_cast<void*>(payload));
 
  // How to save to file?
  return 0;
}