StandaloneDataIO Struct Reference

#include <StandaloneDataIO.h>

Collaboration diagram for StandaloneDataIO:

Classes
struct	ConstantInformation
struct	EventInformation
struct	FolderLoad
class	FolderLoadOptions
	The members of this structure should all be initialised by default to false. More...

Public Types
enum class	ErrorState { OK = 0 , ReadError , WriteError }

Static Public Member Functions
static ErrorState	prepare_folder_for_output (const std::filesystem::path &folder, const bool output_errors=true)
static std::string	build_filename (const std::string &prefix, const std::string &text, const std::string &suffix, const std::string &ext)
static std::string	build_filename (const std::string &prefix, const size_t event_number, const std::string &suffix, const std::string &ext, const unsigned int num_width=9)
static ErrorState	save_constants_to_folder (const std::filesystem::path &folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::GeometryArr > &geo, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellNoiseArr > &noise, const std::string &prefix="", const std::string &suffix="", const bool output_errors=true)
static ErrorState	save_event_to_folder (const size_t event_number, const std::filesystem::path &folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > &cell_info, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > &clusters, const std::string &prefix="", const std::string &suffix="", const unsigned int num_width=9, const bool output_errors=true)
static ErrorState	save_cell_info_to_folder (const size_t event_number, const std::filesystem::path &folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > &cell_info, const std::string &prefix="", const std::string &suffix="", const unsigned int num_width=9, const bool output_errors=true)
static ErrorState	save_clusters_to_folder (const size_t event_number, const std::filesystem::path &folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > &clusters, const std::string &prefix="", const std::string &suffix="", const unsigned int num_width=9, const bool output_errors=true)
template<class F>
static FolderLoad	load_folder_filter (F &&filter_function, const std::filesystem::path &folder, int max_events=-1, const FolderLoadOptions &flo=FolderLoadOptions::None(), const bool output_messages=true)
static FolderLoad	load_folder (const std::filesystem::path &folder, int max_events=-1, const FolderLoadOptions &flo=FolderLoadOptions::None(), const bool output_messages=true)

Static Protected Member Functions
static void	report_error (const std::filesystem::path &file, const std::string &kind, const bool really_report=false)
static bool	create_or_check_folder (const std::filesystem::path &folder, const bool output_errors=true)

Detailed Description

Definition at line 23 of file StandaloneDataIO.h.

Member Enumeration Documentation

ErrorState

enum class StandaloneDataIO::ErrorState

strong

Enumerator
OK
ReadError
WriteError

Definition at line 25 of file StandaloneDataIO.h.

  {
    OK = 0, ReadError, WriteError
  };

Member Function Documentation

build_filename() [1/2]

std::string StandaloneDataIO::build_filename ( const std::string & prefix, const size_t event_number, const std::string & suffix, const std::string & ext, const unsigned int num_width = 9 )

inlinestatic

Definition at line 354 of file StandaloneDataIO.h.

  {
    std::ostringstream event_ID_format;
    event_ID_format << std::setfill('0') << std::setw(num_width) << event_number;
    const std::string event_ID = event_ID_format.str();
    return build_filename(prefix, event_ID, suffix, ext);
  }

build_filename() [2/2]

std::string StandaloneDataIO::build_filename ( const std::string & prefix, const std::string & text, const std::string & suffix, const std::string & ext )

inlinestatic

Definition at line 345 of file StandaloneDataIO.h.

  {
    return prefix + (prefix.size() > 0 ? "_" : "") + text +
           (suffix.size() > 0 ? "_" : "") + suffix + "." + ext;
  }

create_or_check_folder()

bool StandaloneDataIO::create_or_check_folder ( const std::filesystem::path & folder, const bool output_errors = true )

inlinestaticprotected

Definition at line 310 of file StandaloneDataIO.h.

  {
    if (!std::filesystem::exists(folder))
      {
        if (!std::filesystem::create_directory(folder))
          {
            if (output_errors)
              {
                std::cout << "ERROR: folder '" << folder << "' could not be created." << std::endl;
              }
            return false;
          }
      }
    else if (!std::filesystem::is_directory(folder))
      {
        if (output_errors)
          {
            std::cout << "ERROR: folder '" << folder << "' is not a valid folder." << std::endl;
          }
        return false;
      }
    return true;
  }

load_folder()

FolderLoad StandaloneDataIO::load_folder ( const std::filesystem::path & folder, int max_events = -1, const FolderLoadOptions & flo = FolderLoadOptions::None(), const bool output_messages = true )

inlinestatic

Definition at line 649 of file StandaloneDataIO.h.

  {
    return load_folder_filter([&](const std::string &)
    {
      return false;
    },
    folder, max_events, flo, output_messages);
  }

load_folder_filter()

template<class F>

FolderLoad StandaloneDataIO::load_folder_filter ( F && filter_function, const std::filesystem::path & folder, int max_events = -1, const FolderLoadOptions & flo = FolderLoadOptions::None(), const bool output_messages = true )

inlinestatic

Parameters

filter_function

receives a std::string (the filename), returns true if the file should be filtered out.

Definition at line 525 of file StandaloneDataIO.h.

  {
    FolderLoad ret;
    if (!std::filesystem::is_directory(folder))
      {
        if (output_messages)
          {
            std::cout << "ERROR: '" << folder << "' is not a valid folder." << std::endl;
          }
        return ret;
      }
    std::set<std::string> read_one_part_of_v1_cells;
    int event_count = 0;
    for (const std::filesystem::path & file : std::filesystem::directory_iterator(folder))
      {
        if ( max_events > 0 && event_count >= max_events &&
             ret.geometry.size() > 0 && ret.noise.size() > 0 )
          {
            break;
          }
 
        const bool can_load_events = (max_events < 0) || (event_count < max_events);
        const std::string filename = file.stem().native();
 
        if (filter_function(filename))
          {
            continue;
          }
 
        auto check_error = [&](const ErrorState & es, const std::string & str)
        {
          if (es == ErrorState::OK)
            {
              return false;
            }
          if (output_messages)
            {
              std::cout << "ERROR: '" << file << "' is not a valid " << str << " file (" << (int) es << ")." << std::endl;
            }
          return true;
        };
 
        auto output_loading_message = [&](const std::string & str)
        {
          if (output_messages)
            {
              std::cout << "Loaded " << str << " from '" << file << "'." << std::endl;
            }
        };
 
        if (file.extension() == ".geometry")
          {
            if (!flo.load_geometry)
              {
                continue;
              }
            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::GeometryArr> tempgeo(true);
            if (check_error(ConstantInformation::read_geometry(file, tempgeo), "geometry"))
              {
                continue;
              }
            ret.geometry[filename] = std::move(tempgeo);
            output_loading_message("geometry");
          }
        else if (file.extension() == ".cellinfo")
          {
            if (!flo.load_cell_info || !can_load_events)
              {
                continue;
              }
            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellInfoArr> tempcellinfo(true);
            if (check_error(EventInformation::read_cell_info(file, tempcellinfo), "cell info"))
              {
                continue;
              }
            ret.cell_info[filename] = std::move(tempcellinfo);
            output_loading_message("cell info");
            if (ret.cluster_info.count(filename) > 0 || !flo.load_cluster_info)
              {
                ++event_count;
              }
          }
        else if (file.extension() == ".clusterinfo")
          {
            if (!flo.load_cluster_info || !can_load_events)
              {
                continue;
              }
            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::ClusterInfoArr> tempclu(true);
            if (check_error(EventInformation::read_cluster_info(file, tempclu), "cluster info"))
              {
                continue;
              }
            ret.cluster_info[filename] = std::move(tempclu);
            output_loading_message("cluster info");
            if (ret.cell_info.count(filename) > 0 || !flo.load_cell_info)
              {
                ++event_count;
              }
          }
        else if (file.extension() == ".noise")
          {
            if (!flo.load_noise)
              {
                continue;
              }
            CaloRecGPU::Helpers::CPU_object<CaloRecGPU::CellNoiseArr> tempnois(true);
            if (check_error(ConstantInformation::read_noise(file, tempnois), "noise"))
              {
                continue;
              }
            ret.noise[filename] = std::move(tempnois);
            output_loading_message("noise");
          }
      }
    return ret;
  }

prepare_folder_for_output()

ErrorState StandaloneDataIO::prepare_folder_for_output ( const std::filesystem::path & folder, const bool output_errors = true )

inlinestatic

Definition at line 336 of file StandaloneDataIO.h.

  {
    if (!create_or_check_folder(folder, output_errors))
      {
        return ErrorState::WriteError;
      }
    return ErrorState::OK;
  }

report_error()

void StandaloneDataIO::report_error ( const std::filesystem::path & file, const std::string & kind, const bool really_report = false )

inlinestaticprotected

Definition at line 32 of file StandaloneDataIO.h.

  {
    if (really_report)
      {
        std::cerr << "ERROR: when " << kind << " from '" << file << "'." << std::endl;
      }
  }

save_cell_info_to_folder()

ErrorState StandaloneDataIO::save_cell_info_to_folder ( const size_t event_number, const std::filesystem::path & folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > & cell_info, const std::string & prefix = "", const std::string & suffix = "", const unsigned int num_width = 9, const bool output_errors = true )

inlinestatic

Definition at line 429 of file StandaloneDataIO.h.

  {
    if (!create_or_check_folder(folder, output_errors))
      {
        return ErrorState::WriteError;
      }
 
    std::ostringstream event_ID_format;
    event_ID_format << std::setfill('0') << std::setw(num_width) << event_number;
    const std::string event_ID = event_ID_format.str();
 
    auto filename = [&] (const std::string & ext)
    {
      return folder / build_filename(prefix, event_ID, suffix, ext);
    };
 
    if (EventInformation::write_cell_info(filename("cellinfo"), cell_info) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    return ErrorState::OK;
  }

save_clusters_to_folder()

ErrorState StandaloneDataIO::save_clusters_to_folder ( const size_t event_number, const std::filesystem::path & folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > & clusters, const std::string & prefix = "", const std::string & suffix = "", const unsigned int num_width = 9, const bool output_errors = true )

inlinestatic

Definition at line 458 of file StandaloneDataIO.h.

  {
    if (!create_or_check_folder(folder, output_errors))
      {
        return ErrorState::WriteError;
      }
 
    std::ostringstream event_ID_format;
    event_ID_format << std::setfill('0') << std::setw(num_width) << event_number;
    const std::string event_ID = event_ID_format.str();
 
    auto filename = [&] (const std::string & ext)
    {
      return folder / build_filename(prefix, event_ID, suffix, ext);
    };
 
    if (EventInformation::write_cluster_info(filename("clusters"), clusters) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    return ErrorState::OK;
  }

save_constants_to_folder()

ErrorState StandaloneDataIO::save_constants_to_folder ( const std::filesystem::path & folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::GeometryArr > & geo, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellNoiseArr > & noise, const std::string & prefix = "", const std::string & suffix = "", const bool output_errors = true )

inlinestatic

Definition at line 367 of file StandaloneDataIO.h.

  {
    if (!create_or_check_folder(folder, output_errors))
      {
        return ErrorState::WriteError;
      }
 
    auto filename = [&] (const std::string & text, const std::string & ext)
    {
      return folder / build_filename(prefix, text, suffix, ext);
    };
 
    if (ConstantInformation::write_geometry(filename("geometry", "geo"), geo) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    if (ConstantInformation::write_noise(filename("noise", "noise"), noise) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    return ErrorState::OK;
  }

save_event_to_folder()

ErrorState StandaloneDataIO::save_event_to_folder ( const size_t event_number, const std::filesystem::path & folder, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > & cell_info, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > & clusters, const std::string & prefix = "", const std::string & suffix = "", const unsigned int num_width = 9, const bool output_errors = true )

inlinestatic

Definition at line 395 of file StandaloneDataIO.h.

  {
    if (!create_or_check_folder(folder, output_errors))
      {
        return ErrorState::WriteError;
      }
 
    std::ostringstream event_ID_format;
    event_ID_format << std::setfill('0') << std::setw(num_width) << event_number;
    const std::string event_ID = event_ID_format.str();
 
    auto filename = [&] (const std::string & ext)
    {
      return folder / build_filename(prefix, event_ID, suffix, ext);
    };
 
    if (EventInformation::write_cell_info(filename("cellinfo"), cell_info) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    if (EventInformation::write_cluster_info(filename("clusterinfo"), clusters) != ErrorState::OK)
      {
        return ErrorState::WriteError;
      }
    return ErrorState::OK;
  }

---

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

• StandaloneDataIO.h