DataIO.h File Reference

Go to the source code of this file.

Classes
class	libMesh::DenseMatrix< T >
class	libMesh::DenseVector< T >
class	libMesh::VectorValue< T >
class	libMesh::TensorValue< T >
struct	Moose::MFEM::SolutionState
class	libMesh::Parallel::Packing< std::basic_string< T > >

Namespaces
	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.
	Moose::MFEM
	Utilities for converting between vector(s) of libMesh Points and MFEM Vector(s).
	libMesh::Parallel

Functions
template<typename P >
void	storeHelper (std::ostream &stream, P &data, void *context)
	Scalar helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::vector< P > &data, void *context)
	Vector helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::shared_ptr< P > &data, void *context)
	Shared pointer helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::unique_ptr< P > &data, void *context)
	Unique pointer helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::set< P > &data, void *context)
	Set helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::map< P, Q > &data, void *context)
	Map helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::optional< P > &data, void *context)
	Optional helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, HashMap< P, Q > &data, void *context)
	HashMap helper routine. More...
template<typename T >
void	storeHelper (std::ostream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, P &data, void *context)
	Scalar helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::vector< P > &data, void *context)
	Vector helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::shared_ptr< P > &data, void *context)
	Shared Pointer helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::unique_ptr< P > &data, void *context)
	Unique Pointer helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::set< P > &data, void *context)
	Set helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::map< P, Q > &data, void *context)
	Map helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::optional< P > &data, void *context)
	Optional helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, HashMap< P, Q > &data, void *context)
	Hashmap helper routine. More...
template<typename T >
void	loadHelper (std::istream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine. More...
template<typename T >
void	dataStore (std::ostream &stream, T &v, void *)
template<typename T >
void	dataStore (std::ostream &, T *&, void *)
void	dataStore (std::ostream &stream, Point &p, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::pair< T, U > &p, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::vector< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::shared_ptr< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::unique_ptr< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::set< T > &s, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::list< T > &l, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::deque< T > &l, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::map< T, U > &m, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::unordered_map< T, U > &m, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::unordered_set< T > &s, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::optional< T > &m, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, HashMap< T, U > &m, void *context)
template<typename T , int Rows, int Cols>
void	dataStore (std::ostream &stream, Eigen::Matrix< T, Rows, Cols > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, GenericTwoVector< T > &v, void *context)
template<>
void	dataStore (std::ostream &stream, Real &v, void *context)
template<>
void	dataStore (std::ostream &stream, std::string &v, void *context)
template<>
void	dataStore (std::ostream &stream, VariableName &v, void *context)
template<>
void	dataStore (std::ostream &stream, UserObjectName &v, void *context)
template<>
void	dataStore (std::ostream &stream, bool &v, void *context)
template<>
void	dataStore (std::ostream &stream, libMesh::FEType &v, void *context)
template<>
void	dataStore (std::ostream &stream, std::vector< bool > &v, void *context)
template<>
void	dataStore (std::ostream &stream, const Elem *&e, void *context)
template<>
void	dataStore (std::ostream &stream, const Node *&n, void *context)
template<>
void	dataStore (std::ostream &stream, Elem *&e, void *context)
template<>
void	dataStore (std::ostream &stream, Node *&n, void *context)
template<>
void	dataStore (std::ostream &stream, std::stringstream &s, void *context)
template<>
void	dataStore (std::ostream &stream, ADReal &dn, void *context)
template<>
void	dataStore (std::ostream &stream, torch::Tensor &t, void *context)
template<>
void	dataStore (std::ostream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataStore (std::ostream &stream, Moose::MFEM::SolutionState &state, void *context)
template<>
void	dataStore (std::ostream &stream, std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &v, void *context)
	Stores an owned numeric vector. More...
template<std::size_t N>
void	dataStore (std::ostream &stream, std::array< ADReal, N > &dn, void *context)
template<std::size_t N>
void	dataStore (std::ostream &stream, ADReal(&dn)[N], void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::NumericVector< T > &v, void *context)
template<>
void	dataStore (std::ostream &stream, Vec &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, DenseVector< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::TensorValue< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::DenseMatrix< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::VectorValue< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankThreeTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataStore (std::ostream &stream, SymmetricRankTwoTensorTempl< T > &srtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, SymmetricRankFourTensorTempl< T > &srft, void *context)
template<typename T >
void	dataStore (std::ostream &stream, ColumnMajorMatrixTempl< T > &cmm, void *context)
template<typename T >
void	dataLoad (std::istream &stream, T &v, void *)
template<typename T >
void	dataLoad (std::istream &, T *&, void *)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::pair< T, U > &p, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::vector< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::shared_ptr< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::unique_ptr< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::set< T > &s, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::list< T > &l, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::deque< T > &l, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::map< T, U > &m, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::unordered_map< T, U > &m, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::unordered_set< T > &s, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::optional< T > &m, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, HashMap< T, U > &m, void *context)
template<typename T , int Rows, int Cols>
void	dataLoad (std::istream &stream, Eigen::Matrix< T, Rows, Cols > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, GenericTwoVector< T > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Real &v, void *)
template<>
void	dataLoad (std::istream &stream, std::string &v, void *)
template<>
void	dataLoad (std::istream &stream, VariableName &v, void *)
template<>
void	dataLoad (std::istream &stream, UserObjectName &v, void *)
template<>
void	dataLoad (std::istream &stream, bool &v, void *)
template<>
void	dataLoad (std::istream &stream, libMesh::FEType &v, void *)
template<>
void	dataLoad (std::istream &stream, std::vector< bool > &v, void *)
template<>
void	dataLoad (std::istream &stream, const Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, const Node *&e, void *context)
template<>
void	dataLoad (std::istream &stream, Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, Node *&e, void *context)
template<>
void	dataLoad (std::istream &stream, std::stringstream &s, void *context)
template<>
void	dataLoad (std::istream &stream, ADReal &dn, void *context)
template<>
void	dataLoad (std::istream &stream, torch::Tensor &t, void *context)
template<>
void	dataLoad (std::istream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataLoad (std::istream &stream, Moose::MFEM::SolutionState &state, void *context)
template<>
void	dataLoad (std::istream &stream, std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &v, void *context)
	Loads an owned numeric vector. More...
template<std::size_t N>
void	dataLoad (std::istream &stream, std::array< ADReal, N > &dn, void *context)
template<std::size_t N>
void	dataLoad (std::istream &stream, ADReal(&dn)[N], void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::NumericVector< T > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Vec &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, DenseVector< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::TensorValue< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::DenseMatrix< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::VectorValue< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankThreeTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataLoad (std::istream &stream, SymmetricRankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, SymmetricRankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataLoad (std::istream &stream, ColumnMajorMatrixTempl< T > &cmm, void *context)
void	dataLoad (std::istream &stream, Point &p, void *context)

Function Documentation

dataLoad() [1/48]

template<typename T >

void dataLoad ( std::istream &  stream, T &  v, void *    )

inline

Definition at line 581 of file DataIO.h.

Referenced by dataLoad(), and loadHelper().

{
  stream.read((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to load");
}

dataLoad() [2/48]

template<typename T >

void dataLoad	(	std::istream &	,
		T *&	,
		void *
	)

Definition at line 589 of file DataIO.h.

{
  mooseError("Attempting to load a raw pointer type: \"",
             libMesh::demangle(typeid(T).name()),
             " *\" as restartable data!\nWrite a custom dataLoad() template specialization!\n\n");
}

dataLoad() [3/48]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::pair< T, U > &  p, void *  context  )

inline

Definition at line 598 of file DataIO.h.

{
  loadHelper(stream, p.first, context);
  loadHelper(stream, p.second, context);
}

dataLoad() [4/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::vector< T > &  v, void *  context  )

inline

Definition at line 606 of file DataIO.h.

{
  // First read the size of the vector
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  v.resize(size);

  for (unsigned int i = 0; i < size; i++)
    loadHelper(stream, v[i], context);
}

dataLoad() [5/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::shared_ptr< T > &  v, void *  context  )

inline

Definition at line 620 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [6/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::unique_ptr< T > &  v, void *  context  )

inline

Definition at line 629 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [7/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::set< T > &  s, void *  context  )

inline

Definition at line 638 of file DataIO.h.

{
  // First read the size of the set
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    s.insert(std::move(data));
  }
}

dataLoad() [8/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::list< T > &  l, void *  context  )

inline

Definition at line 654 of file DataIO.h.

{
  // First read the size of the set
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    l.push_back(std::move(data));
  }
}

dataLoad() [9/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::deque< T > &  l, void *  context  )

inline

Definition at line 670 of file DataIO.h.

{
  // First read the size of the container
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    l.push_back(std::move(data));
  }
}

dataLoad() [10/48]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::map< T, U > &  m, void *  context  )

inline

Definition at line 686 of file DataIO.h.

{
  m.clear();

  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [11/48]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::unordered_map< T, U > &  m, void *  context  )

inline

Definition at line 706 of file DataIO.h.

{
  m.clear();

  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [12/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::unordered_set< T > &  s, void *  context  )

inline

Definition at line 726 of file DataIO.h.

{
  s.clear();

  // First read the size of the set
  std::size_t size = 0;
  dataLoad(stream, size, nullptr);
  s.reserve(size);

  for (std::size_t i = 0; i < size; i++)
  {
    T element;
    dataLoad(stream, element, context);
    s.insert(element);
  }
}

dataLoad() [13/48]

template<typename T >

void dataLoad ( std::istream &  stream, std::optional< T > &  m, void *  context  )

inline

Definition at line 745 of file DataIO.h.

{
  bool has_value;
  dataLoad(stream, has_value, nullptr);

  if (has_value)
  {
    m = T{};
    loadHelper(stream, *m, context);
  }
  else
    m.reset();
}

dataLoad() [14/48]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, HashMap< T, U > &  m, void *  context  )

inline

Definition at line 761 of file DataIO.h.

{
  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [15/48]

template<typename T , int Rows, int Cols>

void dataLoad	(	std::istream &	stream,
		Eigen::Matrix< T, Rows, Cols > &	v,
		void *	context
	)

Definition at line 779 of file DataIO.h.

{
  unsigned int m = 0;
  dataLoad(stream, m, context);
  unsigned int n = 0;
  dataLoad(stream, n, context);
  v.resize(m, n);
  for (const auto i : make_range(m))
    for (const auto j : make_range(n))
    {
      T r{};
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [16/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		GenericTwoVector< T > &	v,
		void *	context
	)

Definition at line 797 of file DataIO.h.

{
  dataLoad(stream, static_cast<Eigen::Matrix<T, 2, 1> &>(v), context);
}

dataLoad() [17/48]

template<>

void dataLoad	(	std::istream &	stream,
		Real &	v,
		void *
	)

Definition at line 396 of file DataIO.C.

Referenced by dataLoad().

{
  stream.read((char *)&v, sizeof(v));
}

dataLoad() [18/48]

template<>

void dataLoad	(	std::istream &	stream,
		std::string &	v,
		void *
	)

Definition at line 403 of file DataIO.C.

{
  // Read the size of the string
  unsigned int size = 0;
  stream.read((char *)&size, sizeof(size));

  // Resize the string data
  v.resize(size);

  // Read the string
  stream.read(&v[0], sizeof(char) * size);
}

dataLoad() [19/48]

template<>

void dataLoad	(	std::istream &	stream,
		VariableName &	v,
		void *
	)

Definition at line 418 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataLoad(stream, name, context);
}

dataLoad() [20/48]

template<>

void dataLoad	(	std::istream &	stream,
		UserObjectName &	v,
		void *
	)

Definition at line 426 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataLoad(stream, name, context);
}

dataLoad() [21/48]

template<>

void dataLoad	(	std::istream &	stream,
		bool &	v,
		void *
	)

Definition at line 434 of file DataIO.C.

{
  stream.read((char *)&v, sizeof(v));
}

dataLoad() [22/48]

template<>

void dataLoad	(	std::istream &	stream,
		libMesh::FEType &	v,
		void *
	)

Definition at line 441 of file DataIO.C.

{
  int order = 0;
  dataLoad(stream, order, context);
  v.order = order;

  dataLoad(stream, v.family, context);

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  int radial_order = 0;
  dataLoad(stream, radial_order, context);
  v.radial_order = radial_order;

  dataLoad(stream, v.radial_family, context);
  dataLoad(stream, v.inf_map, context);
#endif

  dataLoad(stream, v.p_refinement, context);
}

dataLoad() [23/48]

template<>

void dataLoad	(	std::istream &	stream,
		std::vector< bool > &	v,
		void *
	)

Definition at line 463 of file DataIO.C.

{
  for (bool b : v)
    dataLoad(stream, b, context);
}

dataLoad() [24/48]

template<>

void dataLoad	(	std::istream &	stream,
		const Elem *&	e,
		void *	context
	)

dataLoad() [25/48]

template<>

void dataLoad	(	std::istream &	stream,
		const Node *&	e,
		void *	context
	)

dataLoad() [26/48]

template<>

void dataLoad	(	std::istream &	stream,
		Elem *&	e,
		void *	context
	)

dataLoad() [27/48]

template<>

void dataLoad	(	std::istream &	stream,
		Node *&	e,
		void *	context
	)

dataLoad() [28/48]

template<>

void dataLoad	(	std::istream &	stream,
		std::stringstream &	s,
		void *	context
	)

Definition at line 572 of file DataIO.C.

{
  size_t s_size = 0;
  stream.read((char *)&s_size, sizeof(s_size));

  std::unique_ptr<char[]> s_s = std::make_unique<char[]>(s_size);
  stream.read(s_s.get(), s_size);

  // Clear the stringstream before loading new data into it.
  s.str(std::string());
  s.write(s_s.get(), s_size);
}

dataLoad() [29/48]

template<>

void dataLoad	(	std::istream &	stream,
		ADReal &	dn,
		void *	context
	)

Definition at line 471 of file DataIO.C.

{
  dataLoad(stream, dn.value(), context);

  if (ADReal::do_derivatives)
  {
    auto & derivatives = dn.derivatives();
    std::size_t size = 0;
    stream.read((char *)&size, sizeof(size));
    derivatives.resize(size);

    for (MooseIndex(derivatives) i = 0; i < derivatives.size(); ++i)
    {
      dataLoad(stream, derivatives.raw_index(i), context);
      dataLoad(stream, derivatives.raw_at(i), context);
    }
  }
}

dataLoad() [30/48]

template<>

void dataLoad	(	std::istream &	stream,
		torch::Tensor &	t,
		void *	context
	)

Definition at line 588 of file DataIO.C.

{
  unsigned int rank = 0;
  dataLoad(stream, rank, nullptr);

  std::vector<int64_t> sizes(rank);
  for (unsigned int dim = 0; dim < rank; ++dim)
  {
    unsigned int size = 0;
    dataLoad(stream, size, nullptr);
    sizes[dim] = size;
  }

  t = torch::empty(sizes, at::kDouble);
  auto flattened = t.reshape({t.numel()});
  auto t_accessor = flattened.accessor<Real, 1>();
  for (int64_t i = 0; i < flattened.numel(); ++i)
  {
    Real r = 0;
    dataLoad(stream, r, context);
    t_accessor[i] = r;
  }
}

dataLoad() [31/48]

template<>

void dataLoad	(	std::istream &	stream,
		libMesh::Parameters &	p,
		void *	context
	)

Definition at line 681 of file DataIO.C.

{
  p.clear();

  // First read the size of the map
  unsigned int size = 0;
  stream.read((char *)&size, sizeof(size));

  for (unsigned int i = 0; i < size; i++)
  {
    std::string key, type;
    loadHelper(stream, key, context);
    loadHelper(stream, type, context);

#define loadscalar(ptype)                                                                          \
  else if (type == demangle(typeid(ptype).name())) do                                              \
  {                                                                                                \
    ptype & value = p.set<ptype>(key);                                                             \
    loadHelper(stream, value, context);                                                            \
  }                                                                                                \
  while (0)

    if (false)
      ;
    loadscalar(Real);
    loadscalar(short);
    loadscalar(int);
    loadscalar(long);
    loadscalar(unsigned short);
    loadscalar(unsigned int);
    loadscalar(unsigned long);

#undef loadscalar
  }
}

dataLoad() [32/48]

template<>

void dataLoad	(	std::istream &	stream,
		Moose::MFEM::SolutionState &	state,
		void *	context
	)

Definition at line 77 of file SolutionStateData.C.

{
  auto * const data = static_cast<MFEMProblemData *>(context);

  int num_gridfunctions = 0;
  dataLoad(stream, num_gridfunctions, context);
  for (int i = 0; i < num_gridfunctions; ++i)
  {
    std::string name;
    dataLoad(stream, name, context);
    auto & gf = data->gridfunctions.GetRef(name);
    loadGridFunction(stream, gf, context);
  }

  int num_complex_gridfunctions = 0;
  dataLoad(stream, num_complex_gridfunctions, context);
  for (int i = 0; i < num_complex_gridfunctions; ++i)
  {
    std::string name;
    dataLoad(stream, name, context);
    auto & gf = data->cmplx_gridfunctions.GetRef(name);
    loadGridFunction(stream, gf.real(), context);
    loadGridFunction(stream, gf.imag(), context);
  }
}

dataLoad() [33/48]

template<>

void dataLoad	(	std::istream &	stream,
		std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &	v,
		void *	context
	)

Loads an owned numeric vector.

This is used in lieu of the NumericVector<double> & implementation when the vector may not necessarily be initialized yet on the loading of the data.

If is not null, it must have the same global and local sizes that it was stored with. In this case, the data is simply filled into the vector.

If is null, it will be constructed with the type (currently just a PetscVector) stored and initialized with the global and local sizes stored. The data will then be filled after initialization.

Requirements: the vector cannot be ghosted, the provided context must be the Communicator, and if v is initialized, it must have the same global and local sizes that the vector was stored with.

dataLoad() [34/48]

template<std::size_t N>

void dataLoad ( std::istream &  stream, std::array< ADReal, N > &  dn, void *  context  )

inline

Definition at line 865 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataLoad(stream, dn[i], context);
}

dataLoad() [35/48]

template<std::size_t N>

void dataLoad ( std::istream &  stream, ADReal(&)  dn[N], void *  context  )

inline

Definition at line 873 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataLoad(stream, dn[i], context);
}

dataLoad() [36/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::NumericVector< T > &	v,
		void *	context
	)

Definition at line 881 of file DataIO.h.

{
  numeric_index_type size = v.local_size();
  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
  {
    T r = 0;
    dataLoad(stream, r, context);
    v.set(i, r);
  }
  v.close();
}

dataLoad() [37/48]

template<>

void dataLoad	(	std::istream &	stream,
		Vec &	v,
		void *	context
	)

Definition at line 768 of file DataIO.C.

{
  PetscInt local_size;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetLocalSize(v, &local_size));
  PetscScalar * array;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetArray(v, &array));
  for (PetscInt i = 0; i < local_size; i++)
    dataLoad(stream, array[i], context);

  LibmeshPetscCallA(PETSC_COMM_WORLD, VecRestoreArray(v, &array));
}

dataLoad() [38/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		DenseVector< T > &	v,
		void *	context
	)

Definition at line 898 of file DataIO.h.

{
  unsigned int n = 0;
  dataLoad(stream, n, nullptr);
  v.resize(n);
  for (unsigned int i = 0; i < n; i++)
  {
    T r = 0;
    dataLoad(stream, r, context);
    v(i) = r;
  }
}

dataLoad() [39/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::TensorValue< T > &	v,
		void *	context
	)

Definition at line 615 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
    {
      T r = 0;
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [40/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::DenseMatrix< T > &	v,
		void *	context
	)

Definition at line 633 of file DataIO.C.

{
  unsigned int m = 0, n = 0;
  stream.read((char *)&m, sizeof(m));
  stream.read((char *)&n, sizeof(n));
  v.resize(m, n);
  for (unsigned int i = 0; i < m; i++)
    for (unsigned int j = 0; j < n; j++)
    {
      T r = 0;
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [41/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::VectorValue< T > &	v,
		void *	context
	)

Definition at line 653 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
  {
    T r = 0;
    dataLoad(stream, r, context);
    v(i) = r;
  }
}

dataLoad() [42/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 922 of file DataIO.h.

{
  dataLoad(stream, rtt._coords, context);
}

dataLoad() [43/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankThreeTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 929 of file DataIO.h.

{
  dataLoad(stream, rtt._vals, context);
}

dataLoad() [44/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 936 of file DataIO.h.

{
  dataLoad(stream, rft._vals, context);
}

dataLoad() [45/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		SymmetricRankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 943 of file DataIO.h.

{
  dataLoad(stream, rtt._vals, context);
}

dataLoad() [46/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		SymmetricRankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 950 of file DataIO.h.

{
  dataLoad(stream, rft._vals, context);
}

dataLoad() [47/48]

template<typename T >

void dataLoad	(	std::istream &	stream,
		ColumnMajorMatrixTempl< T > &	cmm,
		void *	context
	)

Definition at line 957 of file DataIO.h.

{
  dataLoad(stream, cmm._values, context);
}

dataLoad() [48/48]

void dataLoad	(	std::istream &	stream,
		Point &	p,
		void *	context
	)

dataStore() [1/48]

template<typename T >

void dataStore ( std::ostream &  stream, T &  v, void *    )

inline

Definition at line 196 of file DataIO.h.

Referenced by dataStore(), and storeHelper().

{
#ifdef LIBMESH_HAVE_CXX11_TYPE_TRAITS
  static_assert(std::is_polymorphic<T>::value == false,
                "Cannot serialize a class that has virtual "
                "members!\nWrite a custom dataStore() "
                "template specialization!\n\n");
  static_assert(std::is_trivially_copyable<T>::value,
                "Cannot serialize a class that is not trivially copyable!\nWrite a custom "
                "dataStore() template specialization!\n\n");
#endif

  stream.write((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to store");
}

dataStore() [2/48]

template<typename T >

void dataStore ( std::ostream &  , T *&  , void *    )

inline

Definition at line 214 of file DataIO.h.

{
  mooseError("Attempting to store a raw pointer type: \"",
             libMesh::demangle(typeid(T).name()),
             " *\" as restartable data!\nWrite a custom dataStore() template specialization!\n\n");
}

dataStore() [3/48]

void dataStore	(	std::ostream &	stream,
		Point &	p,
		void *	context
	)

dataStore() [4/48]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::pair< T, U > &  p, void *  context  )

inline

Definition at line 225 of file DataIO.h.

{
  storeHelper(stream, p.first, context);
  storeHelper(stream, p.second, context);
}

dataStore() [5/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::vector< T > &  v, void *  context  )

inline

Definition at line 233 of file DataIO.h.

{
  // First store the size of the vector
  unsigned int size = v.size();
  dataStore(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
    storeHelper(stream, v[i], context);
}

dataStore() [6/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::shared_ptr< T > &  v, void *  context  )

inline

Definition at line 245 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [7/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::unique_ptr< T > &  v, void *  context  )

inline

Definition at line 254 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [8/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::set< T > &  s, void *  context  )

inline

Definition at line 263 of file DataIO.h.

{
  // First store the size of the set
  unsigned int size = s.size();
  dataStore(stream, size, nullptr);

  typename std::set<T>::iterator it = s.begin();
  typename std::set<T>::iterator end = s.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [9/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::list< T > &  l, void *  context  )

inline

Definition at line 281 of file DataIO.h.

{
  // First store the size of the set
  unsigned int size = l.size();
  dataStore(stream, size, nullptr);

  typename std::list<T>::iterator it = l.begin();
  typename std::list<T>::iterator end = l.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [10/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::deque< T > &  l, void *  context  )

inline

Definition at line 299 of file DataIO.h.

{
  // First store the size of the container
  unsigned int size = l.size();
  dataStore(stream, size, nullptr);

  typename std::deque<T>::iterator it = l.begin();
  typename std::deque<T>::iterator end = l.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [11/48]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::map< T, U > &  m, void *  context  )

inline

Definition at line 317 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename std::map<T, U>::iterator it = m.begin();
  typename std::map<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [12/48]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::unordered_map< T, U > &  m, void *  context  )

inline

Definition at line 338 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename std::unordered_map<T, U>::iterator it = m.begin();
  typename std::unordered_map<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [13/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::unordered_set< T > &  s, void *  context  )

inline

Definition at line 359 of file DataIO.h.

{
  // First store the size of the set
  std::size_t size = s.size();
  dataStore(stream, size, nullptr);

  for (auto & element : s)
    dataStore(stream, element, context);
}

dataStore() [14/48]

template<typename T >

void dataStore ( std::ostream &  stream, std::optional< T > &  m, void *  context  )

inline

Definition at line 371 of file DataIO.h.

{
  bool has_value = m.has_value();
  dataStore(stream, has_value, nullptr);

  if (has_value)
    storeHelper(stream, *m, context);
}

dataStore() [15/48]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, HashMap< T, U > &  m, void *  context  )

inline

Definition at line 382 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename HashMap<T, U>::iterator it = m.begin();
  typename HashMap<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [16/48]

template<typename T , int Rows, int Cols>

void dataStore	(	std::ostream &	stream,
		Eigen::Matrix< T, Rows, Cols > &	v,
		void *	context
	)

Definition at line 403 of file DataIO.h.

{
  auto m = cast_int<unsigned int>(v.rows());
  dataStore(stream, m, context);
  auto n = cast_int<unsigned int>(v.cols());
  dataStore(stream, n, context);
  for (const auto i : make_range(m))
    for (const auto j : make_range(n))
    {
      auto & r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [17/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		GenericTwoVector< T > &	v,
		void *	context
	)

Definition at line 419 of file DataIO.h.

{
  dataStore(stream, static_cast<Eigen::Matrix<T, 2, 1> &>(v), context);
}

dataStore() [18/48]

template<>

void dataStore	(	std::ostream &	stream,
		Real &	v,
		void *	context
	)

Definition at line 29 of file DataIO.C.

Referenced by dataStore().

{
  stream.write((char *)&v, sizeof(v));
}

dataStore() [19/48]

template<>

void dataStore	(	std::ostream &	stream,
		std::string &	v,
		void *	context
	)

Definition at line 36 of file DataIO.C.

{
  // Write the size of the string
  unsigned int size = v.size();
  stream.write((char *)&size, sizeof(size));

  // Write the string (Do not store the null byte)
  stream.write(v.c_str(), sizeof(char) * size);
}

dataStore() [20/48]

template<>

void dataStore	(	std::ostream &	stream,
		VariableName &	v,
		void *	context
	)

Definition at line 48 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataStore(stream, name, context);
}

dataStore() [21/48]

template<>

void dataStore	(	std::ostream &	stream,
		UserObjectName &	v,
		void *	context
	)

Definition at line 56 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataStore(stream, name, context);
}

dataStore() [22/48]

template<>

void dataStore	(	std::ostream &	stream,
		bool &	v,
		void *	context
	)

Definition at line 64 of file DataIO.C.

{
  stream.write((char *)&v, sizeof(v));
}

dataStore() [23/48]

template<>

void dataStore	(	std::ostream &	stream,
		libMesh::FEType &	v,
		void *	context
	)

Definition at line 71 of file DataIO.C.

{
  auto order = v.order.get_order();
  dataStore(stream, order, context);

  auto family = v.family;
  dataStore(stream, family, context);

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  auto radial_order = v.radial_order.get_order();
  dataStore(stream, radial_order, context);

  auto radial_family = v.radial_family;
  dataStore(stream, radial_family, context);

  auto inf_map = v.inf_map;
  dataStore(stream, inf_map, context);
#endif

  auto p_refinement = v.p_refinement;
  dataStore(stream, p_refinement, context);
}

dataStore() [24/48]

template<>

void dataStore	(	std::ostream &	stream,
		std::vector< bool > &	v,
		void *	context
	)

Definition at line 96 of file DataIO.C.

{
  for (bool b : v)
    dataStore(stream, b, context);
}

dataStore() [25/48]

template<>

void dataStore	(	std::ostream &	stream,
		const Elem *&	e,
		void *	context
	)

dataStore() [26/48]

template<>

void dataStore	(	std::ostream &	stream,
		const Node *&	n,
		void *	context
	)

dataStore() [27/48]

template<>

void dataStore	(	std::ostream &	stream,
		Elem *&	e,
		void *	context
	)

dataStore() [28/48]

template<>

void dataStore	(	std::ostream &	stream,
		Node *&	n,
		void *	context
	)

dataStore() [29/48]

template<>

void dataStore	(	std::ostream &	stream,
		std::stringstream &	s,
		void *	context
	)

Definition at line 212 of file DataIO.C.

{
  const std::string & s_str = s.str();

  size_t s_size = s_str.size();
  stream.write((char *)&s_size, sizeof(s_size));

  stream.write(s_str.c_str(), sizeof(char) * (s_str.size()));
}

dataStore() [30/48]

template<>

void dataStore	(	std::ostream &	stream,
		ADReal &	dn,
		void *	context
	)

Definition at line 125 of file DataIO.C.

{
  dataStore(stream, dn.value(), context);

  if (ADReal::do_derivatives)
  {
    auto & derivatives = dn.derivatives();
    std::size_t size = derivatives.size();
    dataStore(stream, size, context);
    for (MooseIndex(size) i = 0; i < size; ++i)
    {
      dataStore(stream, derivatives.raw_index(i), context);
      dataStore(stream, derivatives.raw_at(i), context);
    }
  }
}

dataStore() [31/48]

template<>

void dataStore	(	std::ostream &	stream,
		torch::Tensor &	t,
		void *	context
	)

Definition at line 225 of file DataIO.C.

{
  const auto tensor = LibtorchUtils::toCPUContiguous(t);
  mooseAssert(tensor.scalar_type() == at::kDouble,
              "Restart storage currently supports only double tensors.");

  auto rank = cast_int<unsigned int>(tensor.dim());
  dataStore(stream, rank, nullptr);
  for (unsigned int dim = 0; dim < rank; ++dim)
  {
    auto size = cast_int<unsigned int>(tensor.sizes()[dim]);
    dataStore(stream, size, nullptr);
  }

  const auto flattened = tensor.reshape({tensor.numel()});
  const auto t_accessor = flattened.accessor<Real, 1>();
  for (int64_t i = 0; i < flattened.numel(); ++i)
  {
    Real r = t_accessor[i];
    dataStore(stream, r, context);
  }
}

dataStore() [32/48]

template<>

void dataStore	(	std::ostream &	stream,
		libMesh::Parameters &	p,
		void *	context
	)

Definition at line 311 of file DataIO.C.

{
  // First store the size of the map
  unsigned int size = p.n_parameters();
  stream.write((char *)&size, sizeof(size));

  auto it = p.begin();
  auto end = p.end();

  for (; it != end; ++it)
  {
    auto & key = const_cast<std::string &>(it->first);
    auto type = it->second->type();

    storeHelper(stream, key, context);
    storeHelper(stream, type, context);

#define storescalar(ptype)                                                                         \
  else if (it->second->type() == demangle(typeid(ptype).name())) storeHelper(                      \
      stream,                                                                                      \
      (dynamic_cast<libMesh::Parameters::Parameter<ptype> *>(MooseUtils::get(it->second)))->get(), \
      context)

    if (false)
      ;
    storescalar(Real);
    storescalar(short);
    storescalar(int);
    storescalar(long);
    storescalar(unsigned short);
    storescalar(unsigned int);
    storescalar(unsigned long);

#undef storescalar
  }
}

dataStore() [33/48]

template<>

void dataStore	(	std::ostream &	stream,
		Moose::MFEM::SolutionState &	state,
		void *	context
	)

Definition at line 51 of file SolutionStateData.C.

{
  auto * const data = static_cast<MFEMProblemData *>(context);

  auto num_gridfunctions = data->gridfunctions.size();
  dataStore(stream, num_gridfunctions, context);
  for (const auto & [name, gridfunction] : data->gridfunctions)
  {
    auto stored_name = name;
    dataStore(stream, stored_name, context);
    storeGridFunction(stream, *gridfunction, context);
  }

  auto num_complex_gridfunctions = data->cmplx_gridfunctions.size();
  dataStore(stream, num_complex_gridfunctions, context);
  for (const auto & [name, gridfunction] : data->cmplx_gridfunctions)
  {
    auto stored_name = name;
    dataStore(stream, stored_name, context);
    storeGridFunction(stream, gridfunction->real(), context);
    storeGridFunction(stream, gridfunction->imag(), context);
  }
}

dataStore() [34/48]

template<>

void dataStore	(	std::ostream &	stream,
		std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &	v,
		void *	context
	)

Stores an owned numeric vector.

This should be used in lieu of the NumericVector<Number> & implementation when the vector may not necessarily be initialized yet on the loading of the data. It stores the partitioning (total and local number of entries).

Requirements: the unique_ptr must exist (cannot be null), the vector cannot be ghosted, and the provided context must be the Communicator.

dataStore() [35/48]

template<std::size_t N>

void dataStore ( std::ostream &  stream, std::array< ADReal, N > &  dn, void *  context  )

inline

Definition at line 481 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataStore(stream, dn[i], context);
}

dataStore() [36/48]

template<std::size_t N>

void dataStore ( std::ostream &  stream, ADReal(&)  dn[N], void *  context  )

inline

Definition at line 489 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataStore(stream, dn[i], context);
}

dataStore() [37/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::NumericVector< T > &	v,
		void *	context
	)

Definition at line 497 of file DataIO.h.

{
  v.close();

  numeric_index_type size = v.local_size();

  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [38/48]

template<>

void dataStore	(	std::ostream &	stream,
		Vec &	v,
		void *	context
	)

Definition at line 782 of file DataIO.C.

{
  PetscInt local_size;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetLocalSize(v, &local_size));
  PetscScalar * array;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetArray(v, &array));
  for (PetscInt i = 0; i < local_size; i++)
    dataStore(stream, array[i], context);

  LibmeshPetscCallA(PETSC_COMM_WORLD, VecRestoreArray(v, &array));
}

dataStore() [39/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		DenseVector< T > &	v,
		void *	context
	)

Definition at line 515 of file DataIO.h.

{
  unsigned int m = v.size();
  dataStore(stream, m, nullptr);
  for (unsigned int i = 0; i < v.size(); i++)
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [40/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::TensorValue< T > &	v,
		void *	context
	)

Definition at line 251 of file DataIO.C.

{
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
    {
      T r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [41/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::DenseMatrix< T > &	v,
		void *	context
	)

Definition at line 266 of file DataIO.C.

{
  unsigned int m = v.m();
  unsigned int n = v.n();
  stream.write((char *)&m, sizeof(m));
  stream.write((char *)&n, sizeof(n));
  for (unsigned int i = 0; i < m; i++)
    for (unsigned int j = 0; j < n; j++)
    {
      T r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [42/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::VectorValue< T > &	v,
		void *	context
	)

Definition at line 285 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [43/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 537 of file DataIO.h.

{
  dataStore(stream, rtt._coords, context);
}

dataStore() [44/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankThreeTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 544 of file DataIO.h.

{
  dataStore(stream, rtt._vals, context);
}

dataStore() [45/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 551 of file DataIO.h.

{
  dataStore(stream, rft._vals, context);
}

dataStore() [46/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		SymmetricRankTwoTensorTempl< T > &	srtt,
		void *	context
	)

Definition at line 558 of file DataIO.h.

{
  dataStore(stream, srtt._vals, context);
}

dataStore() [47/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		SymmetricRankFourTensorTempl< T > &	srft,
		void *	context
	)

Definition at line 565 of file DataIO.h.

{
  dataStore(stream, srft._vals, context);
}

dataStore() [48/48]

template<typename T >

void dataStore	(	std::ostream &	stream,
		ColumnMajorMatrixTempl< T > &	cmm,
		void *	context
	)

Definition at line 572 of file DataIO.h.

{
  dataStore(stream, cmm._values, context);
}

loadHelper() [1/10]

template<typename P >

void loadHelper ( std::istream &  stream, P &  data, void *  context  )

inline

Scalar helper routine.

Definition at line 1057 of file DataIO.h.

Referenced by dataLoad(), MaterialPropertyBase< T, false >::load(), loadHelper(), ReporterState< std::vector< T > >::loadInternal(), and RestartableData< std::list< T > >::loadInternal().

{
  dataLoad(stream, data, context);
}

loadHelper() [2/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::vector< P > &  data, void *  context  )

inline

Vector helper routine.

Definition at line 1065 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [3/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::shared_ptr< P > &  data, void *  context  )

inline

Shared Pointer helper routine.

Definition at line 1073 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [4/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::unique_ptr< P > &  data, void *  context  )

inline

Unique Pointer helper routine.

Definition at line 1081 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [5/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::set< P > &  data, void *  context  )

inline

Set helper routine.

Definition at line 1089 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [6/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, std::map< P, Q > &  data, void *  context  )

inline

Map helper routine.

Definition at line 1097 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [7/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, std::unordered_map< P, Q > &  data, void *  context  )

inline

Unordered_map helper routine.

Definition at line 1105 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [8/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::optional< P > &  data, void *  context  )

inline

Optional helper routine.

Definition at line 1113 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [9/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, HashMap< P, Q > &  data, void *  context  )

inline

Hashmap helper routine.

Definition at line 1121 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [10/10]

template<typename T >

void loadHelper ( std::istream &  stream, UniqueStorage< T > &  data, void *  context  )

inline

UniqueStorage helper routine.

UniqueStorage Helper Function.

The unique_ptr<T> loader is called to load the data. That is, you will likely need a specialization of unique_ptr<T> that will appropriately construct and then fill the piece of data.

Definition at line 1135 of file DataIO.h.

{
  std::size_t size;
  dataLoad(stream, size, nullptr);
  data.resize(size);

  for (const auto i : index_range(data))
    loadHelper(stream, data.pointerValue(i), context);
}

storeHelper() [1/10]

template<typename P >

void storeHelper ( std::ostream &  stream, P &  data, void *  context  )

inline

Scalar helper routine.

Definition at line 965 of file DataIO.h.

Referenced by dataStore(), MaterialPropertyBase< T, false >::store(), storeHelper(), ReporterState< std::vector< T > >::storeInternal(), and RestartableData< std::list< T > >::storeInternal().

{
  dataStore(stream, data, context);
}

storeHelper() [2/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::vector< P > &  data, void *  context  )

inline

Vector helper routine.

Definition at line 973 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [3/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::shared_ptr< P > &  data, void *  context  )

inline

Shared pointer helper routine.

Definition at line 981 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [4/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::unique_ptr< P > &  data, void *  context  )

inline

Unique pointer helper routine.

Definition at line 989 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [5/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::set< P > &  data, void *  context  )

inline

Set helper routine.

Definition at line 997 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [6/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, std::map< P, Q > &  data, void *  context  )

inline

Map helper routine.

Definition at line 1005 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [7/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, std::unordered_map< P, Q > &  data, void *  context  )

inline

Unordered_map helper routine.

Definition at line 1013 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [8/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::optional< P > &  data, void *  context  )

inline

Optional helper routine.

Definition at line 1021 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [9/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, HashMap< P, Q > &  data, void *  context  )

inline

HashMap helper routine.

Definition at line 1029 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [10/10]

template<typename T >

void storeHelper ( std::ostream &  stream, UniqueStorage< T > &  data, void *  context  )

inline

UniqueStorage helper routine.

The data within the UniqueStorage object cannot be null. The helper for unique_ptr<T> is called to store the data.

Definition at line 1042 of file DataIO.h.

{
  std::size_t size = data.size();
  dataStore(stream, size, nullptr);

  for (const auto i : index_range(data))
  {
    mooseAssert(data.hasValue(i), "Data doesn't have a value");
    storeHelper(stream, data.pointerValue(i), context);
  }
}