io_parameters.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2026 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#pragma once
 
#include <deal.II/base/data_out_base.h>
#include <deal.II/base/parameter_handler.h>
#include <deal.II/base/patterns.h>
#include <deal.II/base/utilities.h>
 
#include <boost/serialization/vector.hpp>
 
#include <prismspf/core/conditional_ostreams.h>
#include <prismspf/core/exceptions.h>
#include <prismspf/core/type_enums.h>
#include <prismspf/core/types.h>
 
#include <prismspf/user_inputs/parameter_base.h>
 
#include <prismspf/utilities/utilities.h>
 
#include <prismspf/config.h>
 
#include <climits>
#include <concepts>
#include <execution>
#include <set>
#include <string>
#include <unordered_map>
 
PRISMS_PF_BEGIN_NAMESPACE
 
inline void
add_equal_spacing_outputs(unsigned int            n_outputs,
                          unsigned int            n_increments,
                          std::set<unsigned int> &output_list)
{
  output_list.clear();
  if (n_increments == 0)
    {
      output_list.insert(0);
      return;
    }
  if (!n_outputs)
    {
      return;
    }
 
  unsigned int period = std::max(1U, n_increments / n_outputs);
  for (unsigned int output = 0; output <= n_increments; output += period)
    {
      output_list.insert(output);
    }
}
 
inline void
add_log_spacing_outputs(unsigned int            n_outputs,
                        unsigned int            n_increments,
                        std::set<unsigned int> &output_list)
{
  output_list.clear();
  if (n_increments == 0)
    {
      output_list.insert(0);
      return;
    }
  if (!n_outputs)
    {
      return;
    }
 
  for (unsigned int output = 1; output <= n_outputs; output++)
    {
      output_list.insert((unsigned int) (std::round(
        std::pow(double(n_increments), double(output) / double(n_outputs)))));
    }
}
 
inline void
add_n_per_decade_outputs(unsigned int            n_outputs,
                         unsigned int            n_increments,
                         std::set<unsigned int> &output_list)
{
  output_list.clear();
  if (n_increments == 0)
    {
      output_list.insert(0);
      return;
    }
  if (!n_outputs)
    {
      return;
    }
 
  output_list.insert(0);
  output_list.insert(1);
  for (unsigned int iteration = 2; iteration <= n_increments; iteration++)
    {
      const auto decade    = (unsigned int) (std::ceil(std::log10(iteration)));
      const auto step_size = (unsigned int) (std::pow(10, decade) / n_outputs);
      if (iteration % step_size == 0)
        {
          output_list.insert(iteration);
        }
    }
}
 
template <typename T1, typename T2>
requires std::convertible_to<T1, T2>
inline void
add_list_outputs(const std::vector<T1> &list, std::set<T2> &output_list)
{
  for (const auto &val : list)
    {
      output_list.insert(T2(val));
    }
}

struct FieldOutputParameters : public ParameterBase
{
  static void
  declare(dealii::ParameterHandler &parameter_handler,
          unsigned int              n_subsections = Numbers::default_subsections);

  void
  assign(dealii::ParameterHandler &parameter_handler,
         unsigned int              n_subsections = Numbers::default_subsections) override;

  void
  assign(dealii::ParameterHandler &parameter_handler,
         unsigned int              n_increments,
         unsigned int              n_subsections = Numbers::default_subsections);

  void
  validate(const std::vector<FieldAttributes> &field_attributes,
           const std::vector<SolveBlock>      &solve_blocks) const override;

  enum OutputType
  {
    VTU,
    VTK,
    PVTU,
    XDMF
  };

  [[nodiscard]] bool
  should_output(unsigned int increment) const;

  OutputType file_type = OutputType::VTU;

  unsigned int patch_subdivisions = 0;

  dealii::DataOutBase::CompressionLevel compression_level =
    dealii::DataOutBase::CompressionLevel::default_compression;

  std::string folder = "solutions";

  std::string file_name = "solution";

  std::set<unsigned int> output_list = {0};

  std::set<std::string> output_fields;
};

struct RestartOutputParameters : public ParameterBase
{
  static void
  declare(dealii::ParameterHandler &parameter_handler,
          unsigned int              n_subsections = Numbers::default_subsections);

  void
  assign(dealii::ParameterHandler &parameter_handler,
         unsigned int              n_subsections = Numbers::default_subsections) override;

  void
  assign(dealii::ParameterHandler &parameter_handler,
         unsigned int              n_increments,
         unsigned int              n_subsections = Numbers::default_subsections);

  void
  validate(const std::vector<FieldAttributes> &field_attributes,
           const std::vector<SolveBlock>      &solve_blocks) const override;

  [[nodiscard]] bool
  should_output(unsigned int increment) const;

  bool load_from_checkpoint = false;

  std::string folder = "solutions";

  std::string file_name = "checkpoint";

  std::set<unsigned int> output_list = {0};
};

struct InitialConditionFile
{
  enum DataFormatType
  {
    FlatBinary,
    VTKUnstructuredGrid,
    VTKXMLUnstructuredGrid,
    VTKPXMLUnstructuredGrid,
    VTKXMLImageData
  };
 
  // File name
  std::string file_name;
 
  // Data format
  DataFormatType format;
 
  // File variable names
  std::vector<std::string> file_variable_names;
 
  // Simulation variable names
  std::vector<std::string> simulation_variable_names;
 
  // Number of data points in each direction
  std::array<unsigned int, 3> n_data_points = {
    {0, 0, 0}
  };
};

struct FieldInputParameters : public ParameterBase
{
  static void
  declare(dealii::ParameterHandler &parameter_handler,
          unsigned int              n_subsections = Numbers::default_subsections);

  void
  assign(dealii::ParameterHandler &parameter_handler,
         unsigned int              n_subsections = Numbers::default_subsections) override;

  void
  validate(const std::vector<FieldAttributes> &field_attributes,
           const std::vector<SolveBlock>      &solve_blocks) const override;

  bool load_from_file = false;
 
  // Collection of initial condition files
  std::vector<InitialConditionFile> initial_condition_files;
};
 
PRISMS_PF_END_NAMESPACE