TimeSliceProcessor Class Reference

Public Member Functions
	TimeSliceProcessor (std::string input_path, std::string output_path)
	~TimeSliceProcessor ()
void	set_processor (std::function< void(daqdataformats::TimeSlice &)> processor)
void	loop (uint64_t num_records=0, uint64_t offset=0, bool quiet=false)

Private Member Functions
void	open_files (std::string input_path, std::string output_path)
void	close_files ()
void	process (daqdataformats::TimeSlice &tls)

Private Attributes
std::unique_ptr< hdf5libs::HDF5RawDataFile >	m_input_file
std::unique_ptr< hdf5libs::HDF5RawDataFile >	m_output_file
std::function< void(daqdataformats::TimeSlice &)>	m_processor

Detailed Description

Definition at line 22 of file process_tpstream.cxx.

Constructor & Destructor Documentation

TimeSliceProcessor()

TimeSliceProcessor::TimeSliceProcessor	(	std::string	input_path,
		std::string	output_path )

Definition at line 48 of file process_tpstream.cxx.

{
  this->open_files(input_path, output_path);
}

~TimeSliceProcessor()

TimeSliceProcessor::~TimeSliceProcessor

(

)

Definition at line 54 of file process_tpstream.cxx.

{
  this->close_files();
}

Member Function Documentation

close_files()

void TimeSliceProcessor::close_files ( )

private

Definition at line 91 of file process_tpstream.cxx.

                                {
  // Do something?
}

loop()

void TimeSliceProcessor::loop	(	uint64_t	num_records = 0,
		uint64_t	offset = 0,
		bool	quiet = false )

Definition at line 110 of file process_tpstream.cxx.

                                                                          {
 
  // Replace with a record selection?
  auto records = m_input_file->get_all_record_ids();
 
  if (!num_records) {
    num_records = (records.size()-offset);
  }
 
  uint64_t first_rec = offset, last_rec = offset+num_records;
 
  uint64_t i_rec(0);
  for( const auto& rid : records ) {
 
    if (i_rec < first_rec || i_rec >= last_rec ) {
      ++i_rec;
      continue;
    }
 
    if (!quiet)
      fmt::print("\n-- Processing TSL {}:{}\n\n", rid.first, rid.second);
    auto tsl = m_input_file->get_timeslice(rid);
    // Or filter on a selection here using a lambda?
 
    // if (!quiet)
      // fmt::print("TSL number {}\n", tsl.get_header().timeslice_number);
 
    // Add a process method
    this->process(tsl);
 
    if (m_output_file)
      m_output_file->write(tsl);
 
    ++i_rec;
    if(!quiet)
      fmt::print("\n-- Finished TSL {}:{}\n\n", rid.first, rid.second);
 
  }
 
}

open_files()

void TimeSliceProcessor::open_files ( std::string input_path, std::string output_path )

private

Definition at line 61 of file process_tpstream.cxx.

                                                                          {
  // Open input file
  m_input_file = std::make_unique<hdf5libs::HDF5RawDataFile>(input_path);
 
  if (!m_input_file->is_timeslice_type()) {
    fmt::print("ERROR: input file '{}' not of type 'TimeSlice'\n", input_path);
    throw std::runtime_error(fmt::format("ERROR: input file '{}' not of type 'TimeSlice'", input_path));
  }
 
  auto run_number = m_input_file->get_attribute<daqdataformats::run_number_t>("run_number");
  auto file_index = m_input_file->get_attribute<size_t>("file_index");
  auto application_name = m_input_file->get_attribute<std::string>("application_name");
 
  fmt::print("Run Number: {}\nFile Index: {}\nApp name: '{}'\n", run_number, file_index, application_name);
 
  if (!output_path.empty()) {
    // Open output file
    m_output_file = std::make_unique<hdf5libs::HDF5RawDataFile>(
      output_path,
      m_input_file->get_attribute<daqdataformats::run_number_t>("run_number"),
      m_input_file->get_attribute<size_t>("file_index"),
      m_input_file->get_attribute<std::string>("application_name"),
      m_input_file->get_file_layout().get_file_layout_params(),
      m_input_file->get_srcid_geoid_map()
    );
  }
}

process()

void TimeSliceProcessor::process ( daqdataformats::TimeSlice & tls )

private

Definition at line 103 of file process_tpstream.cxx.

                                                          {
  if (m_processor)
    m_processor(tls);
}

set_processor()

void TimeSliceProcessor::set_processor

(

std::function< void(daqdataformats::TimeSlice &)>

processor

)

Definition at line 97 of file process_tpstream.cxx.

                                                                                        {
  m_processor = processor;
}

Member Data Documentation

m_input_file

std::unique_ptr<hdf5libs::HDF5RawDataFile> TimeSliceProcessor::m_input_file

private

Definition at line 26 of file process_tpstream.cxx.

m_output_file

std::unique_ptr<hdf5libs::HDF5RawDataFile> TimeSliceProcessor::m_output_file

private

Definition at line 27 of file process_tpstream.cxx.

m_processor

std::function<void(daqdataformats::TimeSlice&)> TimeSliceProcessor::m_processor

private

Definition at line 35 of file process_tpstream.cxx.

---

The documentation for this class was generated from the following file:

• /github/workspace/dunedaq/sourcecode/trgtools/apps/process_tpstream.cxx