StandaloneDataIO::EventInformation Struct Reference

#include <StandaloneDataIO.h>

Collaboration diagram for StandaloneDataIO::EventInformation:

Static Public Member Functions
static ErrorState	read_cluster_info (const std::filesystem::path &file, CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > &clusters, const bool report=false)
static ErrorState	read_cell_info (const std::filesystem::path &file, CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > &cell_info, const bool report=false)
static ErrorState	write_cluster_info (std::filesystem::path file, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > &clusters, const bool report=false)
static ErrorState	write_cell_info (std::filesystem::path file, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > &cell_info, const bool report=false)

Friends
struct	StandaloneDataIO

Detailed Description

Definition at line 111 of file StandaloneDataIO.h.

Member Function Documentation

read_cell_info()

ErrorState StandaloneDataIO::EventInformation::read_cell_info ( const std::filesystem::path & file, CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > & cell_info, const bool report = false )

inlinestatic

Definition at line 200 of file StandaloneDataIO.h.

    {
      std::ifstream in(file.native(), std::ios_base::binary);
      cell_info.binary_input(in);
      if (in.fail())
        {
          report_error(file, "reading cell info", report);
          return ErrorState::ReadError;
        }
      in.close();
      return ErrorState::OK;
    }

read_cluster_info()

ErrorState StandaloneDataIO::EventInformation::read_cluster_info ( const std::filesystem::path & file, CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > & clusters, const bool report = false )

inlinestatic

Definition at line 116 of file StandaloneDataIO.h.

    {
      clusters.allocate();
 
      std::ifstream in(file.native(), std::ios_base::binary);
 
      auto reader = [&](auto * ptr, const auto & size)
      {
        in.read(reinterpret_cast<char *>(ptr), sizeof(*ptr) * size);
      };
 
      reader(static_cast<CaloRecGPU::ClusterBaseInfo *>(clusters), 1);
 
      if (in.fail() || clusters->number < 0 || clusters->number > CaloRecGPU::NMaxClusters)
        {
          report_error(file, "reading clusters", report);
          return ErrorState::ReadError;
        }
      
      if (clusters->has_basic_info())
        {
          reader(clusters->clusterEnergy, clusters->number);
          reader(clusters->clusterEt,     clusters->number);
          reader(clusters->clusterEta,    clusters->number);
          reader(clusters->clusterPhi,    clusters->number);
          reader(clusters->seedCellIndex, clusters->number);
        }
 
      switch (clusters->state)
        {
          case CaloRecGPU::ClusterInformationState::Tags:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::TagsWithBasicInfo:
            reader(clusters->cells.tags, CaloRecGPU::NCaloCells);
            break;
          case CaloRecGPU::ClusterInformationState::Full:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithBasicInfo:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithMoments:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithExtraMoments:
            reader(clusters->cellsPrefixSum, clusters->number + 1);
            reader(clusters->cells.indices,  clusters->number_cells);
            reader(clusters->cellWeights,    clusters->number_cells);
            reader(clusters->clusterIndices, clusters->number_cells);
            break;
          default:
            break;
        }
 
      if (clusters->has_moments())
        {
          clusters->for_all_moments([&](auto & arr)
          {
            unsigned long long base_size;
            if constexpr (std::is_pointer_v<std::decay_t<decltype(*arr)>>)
              {
                base_size = sizeof(**arr) * sizeof(arr)/sizeof(*arr);
              }
            else
              {
                base_size = sizeof(*arr);
              }
            in.read(reinterpret_cast<char *>(arr), base_size * clusters->number);
          });
        }
 
      if (in.fail())
        {
          report_error(file, "reading clusters", report);
          return ErrorState::ReadError;
        }
 
      in.close();
 
      return ErrorState::OK;
 
    }

write_cell_info()

ErrorState StandaloneDataIO::EventInformation::write_cell_info ( std::filesystem::path file, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::CellInfoArr > & cell_info, const bool report = false )

inlinestatic

Definition at line 290 of file StandaloneDataIO.h.

    {
      file.replace_extension(".cellinfo");
      std::ofstream out(file, std::ios_base::binary);
      cell_info.binary_output(out);
      if (out.fail())
        {
          report_error(file, "writing cell info", report);
          return ErrorState::WriteError;
        }
      out.close();
      return ErrorState::OK;
    }

write_cluster_info()

ErrorState StandaloneDataIO::EventInformation::write_cluster_info ( std::filesystem::path file, const CaloRecGPU::Helpers::CPU_object< CaloRecGPU::ClusterInfoArr > & clusters, const bool report = false )

inlinestatic

Definition at line 215 of file StandaloneDataIO.h.

    {
      file.replace_extension(".clusterinfo");
      std::ofstream out(file, std::ios_base::binary);
 
      auto writer = [&](const auto * ptr, const auto & size)
      {
        out.write(reinterpret_cast<const char *>(ptr), sizeof(*ptr) * size);
      };
 
 
      out.write(reinterpret_cast<const char *>(static_cast<const CaloRecGPU::ClusterBaseInfo *>(clusters)), sizeof(CaloRecGPU::ClusterBaseInfo));
 
      if (clusters->has_basic_info())
        {
          writer(clusters->clusterEnergy, clusters->number);
          writer(clusters->clusterEt,     clusters->number);
          writer(clusters->clusterEta,    clusters->number);
          writer(clusters->clusterPhi,    clusters->number);
          writer(clusters->seedCellIndex, clusters->number);
        }
      
      switch (clusters->state)
        {
          case CaloRecGPU::ClusterInformationState::Tags:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::TagsWithBasicInfo:
            writer(clusters->cells.tags, CaloRecGPU::NCaloCells);
            break;
          case CaloRecGPU::ClusterInformationState::Full:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithBasicInfo:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithMoments:
            [[fallthrough]];
          case CaloRecGPU::ClusterInformationState::WithExtraMoments:
            writer(clusters->cellsPrefixSum, clusters->number + 1);
            writer(clusters->cells.indices,  clusters->number_cells);
            writer(clusters->cellWeights,    clusters->number_cells);
            writer(clusters->clusterIndices, clusters->number_cells);
            break;
          default:
            break;
        }
 
      if (clusters->has_moments())
        {
          clusters->for_all_moments([&](const auto & arr)
          {
            unsigned long long base_size;
            if constexpr (std::is_pointer_v<std::decay_t<decltype(*arr)>>)
              {
                base_size = sizeof(**arr) * sizeof(arr)/sizeof(*arr);
              }
            else
              {
                base_size = sizeof(*arr);
              }
            out.write(reinterpret_cast<const char *>(arr), base_size * clusters->number);
          });
        }
 
      if (out.fail())
        {
          report_error(file, "writing clusters", report);
          return ErrorState::WriteError;
        }
      out.close();
      return ErrorState::OK;
    }

Friends And Related Symbol Documentation

StandaloneDataIO

friend struct StandaloneDataIO

friend

Definition at line 113 of file StandaloneDataIO.h.

---

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

• StandaloneDataIO.h