DataIO.h File Reference

Go to the source code of this file.

Classes
struct	Moose::MFEM::SolutionState
class	libMesh::Parallel::Packing< std::basic_string< T > >

Namespaces
namespace	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.
namespace	Moose
	MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found.
namespace	Moose::MFEM
	Utilities for converting between vector(s) of libMesh Points and MFEM Vector(s).
namespace	libMesh::Parallel

Functions
template<typename P >
void	storeHelper (std::ostream &stream, P &data, void *context)
	Scalar helper routine.
template<typename P >
void	storeHelper (std::ostream &stream, std::vector< P > &data, void *context)
	Vector helper routine.
template<typename P >
void	storeHelper (std::ostream &stream, std::shared_ptr< P > &data, void *context)
	Shared pointer helper routine.
template<typename P >
void	storeHelper (std::ostream &stream, std::unique_ptr< P > &data, void *context)
	Unique pointer helper routine.
template<typename P >
void	storeHelper (std::ostream &stream, std::set< P > &data, void *context)
	Set helper routine.
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::map< P, Q > &data, void *context)
	Map helper routine.
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine.
template<typename P >
void	storeHelper (std::ostream &stream, std::optional< P > &data, void *context)
	Optional helper routine.
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, HashMap< P, Q > &data, void *context)
	HashMap helper routine.
template<typename T >
void	storeHelper (std::ostream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine.
template<typename P >
void	loadHelper (std::istream &stream, P &data, void *context)
	Scalar helper routine.
template<typename P >
void	loadHelper (std::istream &stream, std::vector< P > &data, void *context)
	Vector helper routine.
template<typename P >
void	loadHelper (std::istream &stream, std::shared_ptr< P > &data, void *context)
	Shared Pointer helper routine.
template<typename P >
void	loadHelper (std::istream &stream, std::unique_ptr< P > &data, void *context)
	Unique Pointer helper routine.
template<typename P >
void	loadHelper (std::istream &stream, std::set< P > &data, void *context)
	Set helper routine.
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::map< P, Q > &data, void *context)
	Map helper routine.
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine.
template<typename P >
void	loadHelper (std::istream &stream, std::optional< P > &data, void *context)
	Optional helper routine.
template<typename P , typename Q >
void	loadHelper (std::istream &stream, HashMap< P, Q > &data, void *context)
	Hashmap helper routine.
template<typename T >
void	loadHelper (std::istream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine.
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)
void	dataStore (std::ostream &stream, libMesh::BoundingBox &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.
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.
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)
void	dataLoad (std::istream &stream, libMesh::BoundingBox &p, void *context)

Function Documentation

dataLoad() [1/49]

template<typename T >

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

Definition at line 613 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() [2/49]

template<>

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

Definition at line 475 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() [3/49]

template<std::size_t N>

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

inline

Definition at line 897 of file DataIO.h.

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

dataLoad() [4/49]

template<>

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

Definition at line 438 of file DataIO.C.

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

dataLoad() [5/49]

template<typename T >

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

Definition at line 981 of file DataIO.h.

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

dataLoad() [6/49]

template<>

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

dataLoad() [7/49]

template<>

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

dataLoad() [8/49]

template<typename T >

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

Definition at line 922 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() [9/49]

template<typename T , int Rows, int Cols>

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

Definition at line 803 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() [10/49]

template<>

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

dataLoad() [11/49]

template<typename T >

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

Definition at line 821 of file DataIO.h.

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

dataLoad() [12/49]

template<typename T , typename U >

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

inline

Definition at line 785 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() [13/49]

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

Definition at line 680 of file DataIO.C.

{
  loadHelper(stream, static_cast<std::pair<Point, Point> &>(bbox), context);
}

dataLoad() [14/49]

template<typename T >

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

Definition at line 637 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() [15/49]

template<>

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

Definition at line 445 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() [16/49]

template<typename T >

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

Definition at line 905 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() [17/49]

template<>

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

Definition at line 687 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() [18/49]

template<typename T >

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

Definition at line 619 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() [19/49]

template<typename T >

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

Definition at line 657 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() [20/49]

template<>

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

Definition at line 73 of file SolutionStateData.C.

{
  auto * const data = static_cast<MFEMProblemData *>(context);
 
  int num_gridfunctions = 0;
  dataLoad(stream, num_gridfunctions, context);
  for ([[maybe_unused]] const auto i : make_range(num_gridfunctions))
  {
    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 ([[maybe_unused]] const auto i : make_range(num_complex_gridfunctions))
  {
    std::string name;
    dataLoad(stream, name, context);
    auto & gf = data->cmplx_gridfunctions.GetRef(name);
    loadGridFunction(stream, gf.real(), context);
    loadGridFunction(stream, gf.imag(), context);
  }
}

Referenced by dataLoad().

dataLoad() [21/49]

template<>

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

dataLoad() [22/49]

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

dataLoad() [23/49]

template<typename T >

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

Definition at line 960 of file DataIO.h.

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

dataLoad() [24/49]

template<typename T >

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

Definition at line 953 of file DataIO.h.

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

dataLoad() [25/49]

template<typename T >

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

Definition at line 946 of file DataIO.h.

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

dataLoad() [26/49]

template<>

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

Definition at line 400 of file DataIO.C.

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

Referenced by dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), and dataLoad().

dataLoad() [27/49]

template<std::size_t N>

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

inline

Definition at line 889 of file DataIO.h.

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

dataLoad() [28/49]

template<typename T >

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

inline

Definition at line 694 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() [29/49]

template<typename T >

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

inline

Definition at line 678 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() [30/49]

template<typename T , typename U >

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

inline

Definition at line 710 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() [31/49]

template<typename T >

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

inline

Definition at line 769 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() [32/49]

template<typename T , typename U >

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

inline

Definition at line 622 of file DataIO.h.

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

dataLoad() [33/49]

template<typename T >

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

inline

Definition at line 662 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() [34/49]

template<typename T >

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

inline

Definition at line 644 of file DataIO.h.

{
  T * tmp = v.get();
 
  loadHelper(stream, tmp, context);
}

dataLoad() [35/49]

template<>

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

Definition at line 407 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() [36/49]

template<>

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

Definition at line 576 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() [37/49]

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() [38/49]

template<typename T >

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

inline

Definition at line 653 of file DataIO.h.

{
  T * tmp = v.get();
 
  loadHelper(stream, tmp, context);
}

dataLoad() [39/49]

template<typename T , typename U >

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

inline

Definition at line 730 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() [40/49]

template<typename T >

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

inline

Definition at line 750 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() [41/49]

template<>

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

Definition at line 467 of file DataIO.C.

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

dataLoad() [42/49]

template<typename T >

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

inline

Definition at line 630 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() [43/49]

template<typename T >

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

Definition at line 974 of file DataIO.h.

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

dataLoad() [44/49]

template<typename T >

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

Definition at line 967 of file DataIO.h.

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

dataLoad() [45/49]

template<typename T >

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

inline

Definition at line 594 of file DataIO.h.

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

Referenced by dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), loadHelper(), loadHelper(), loadHelper(), loadHelper(), loadHelper(), loadHelper(), loadHelper(), loadHelper(), and loadHelper().

dataLoad() [46/49]

template<>

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

Definition at line 592 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() [47/49]

template<>

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

Definition at line 430 of file DataIO.C.

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

dataLoad() [48/49]

template<>

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

Definition at line 422 of file DataIO.C.

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

dataLoad() [49/49]

template<>

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

Definition at line 774 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));
}

dataStore() [1/49]

template<typename T >

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

inline

Definition at line 225 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() [2/49]

template<>

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

Definition at line 126 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() [3/49]

template<std::size_t N>

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

inline

Definition at line 502 of file DataIO.h.

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

dataStore() [4/49]

template<>

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

Definition at line 65 of file DataIO.C.

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

dataStore() [5/49]

template<typename T >

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

Definition at line 585 of file DataIO.h.

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

dataStore() [6/49]

template<>

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

dataStore() [7/49]

template<>

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

dataStore() [8/49]

template<typename T >

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

Definition at line 528 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() [9/49]

template<typename T , int Rows, int Cols>

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

Definition at line 416 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() [10/49]

template<>

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

dataStore() [11/49]

template<typename T >

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

Definition at line 432 of file DataIO.h.

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

dataStore() [12/49]

template<typename T , typename U >

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

inline

Definition at line 395 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() [13/49]

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

Definition at line 308 of file DataIO.C.

{
  storeHelper(stream, static_cast<std::pair<Point, Point> &>(bbox), context);
}

dataStore() [14/49]

template<typename T >

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

Definition at line 267 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() [15/49]

template<>

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

Definition at line 72 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() [16/49]

template<typename T >

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

Definition at line 510 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() [17/49]

template<>

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

Definition at line 315 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() [18/49]

template<typename T >

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

Definition at line 252 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() [19/49]

template<typename T >

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

Definition at line 286 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() [20/49]

template<>

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

Definition at line 47 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);
  }
}

Referenced by dataStore().

dataStore() [21/49]

template<>

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

dataStore() [22/49]

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

dataStore() [23/49]

template<typename T >

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

Definition at line 564 of file DataIO.h.

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

dataStore() [24/49]

template<typename T >

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

Definition at line 557 of file DataIO.h.

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

dataStore() [25/49]

template<typename T >

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

Definition at line 550 of file DataIO.h.

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

dataStore() [26/49]

template<>

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

Definition at line 30 of file DataIO.C.

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

Referenced by dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), and dataStore().

dataStore() [27/49]

template<std::size_t N>

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

inline

Definition at line 494 of file DataIO.h.

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

dataStore() [28/49]

template<typename T >

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

inline

Definition at line 312 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() [29/49]

template<typename T >

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

inline

Definition at line 294 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() [30/49]

template<typename T , typename U >

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

inline

Definition at line 330 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() [31/49]

template<typename T >

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

inline

Definition at line 384 of file DataIO.h.

{
  bool has_value = m.has_value();
  dataStore(stream, has_value, nullptr);
 
  if (has_value)
    storeHelper(stream, *m, context);
}

dataStore() [32/49]

template<typename T , typename U >

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

inline

Definition at line 238 of file DataIO.h.

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

dataStore() [33/49]

template<typename T >

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

inline

Definition at line 276 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() [34/49]

template<typename T >

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

inline

Definition at line 258 of file DataIO.h.

{
  T * tmp = v.get();
 
  storeHelper(stream, tmp, context);
}

dataStore() [35/49]

template<>

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

Definition at line 37 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() [36/49]

template<>

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

Definition at line 213 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() [37/49]

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() [38/49]

template<typename T >

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

inline

Definition at line 267 of file DataIO.h.

{
  T * tmp = v.get();
 
  storeHelper(stream, tmp, context);
}

dataStore() [39/49]

template<typename T , typename U >

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

inline

Definition at line 351 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() [40/49]

template<typename T >

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

inline

Definition at line 372 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() [41/49]

template<>

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

Definition at line 97 of file DataIO.C.

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

dataStore() [42/49]

template<typename T >

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

inline

Definition at line 246 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() [43/49]

template<typename T >

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

Definition at line 578 of file DataIO.h.

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

dataStore() [44/49]

template<typename T >

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

Definition at line 571 of file DataIO.h.

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

dataStore() [45/49]

template<typename T >

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

inline

Definition at line 197 of file DataIO.h.

{
#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");
}

Referenced by dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), storeHelper(), storeHelper(), storeHelper(), storeHelper(), storeHelper(), storeHelper(), storeHelper(), storeHelper(), and storeHelper().

dataStore() [46/49]

template<>

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

Definition at line 226 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() [47/49]

template<>

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

Definition at line 57 of file DataIO.C.

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

dataStore() [48/49]

template<>

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

Definition at line 49 of file DataIO.C.

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

dataStore() [49/49]

template<>

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

Definition at line 788 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));
}

loadHelper() [1/10]

template<typename P , typename Q >

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

inline

Hashmap helper routine.

Definition at line 1145 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [2/10]

template<typename P >

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

inline

Scalar helper routine.

Definition at line 1081 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

Referenced by dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), MaterialPropertyBase< T, is_ad >::load(), RestartableData< T >::loadInternal(), and ReporterState< T >::loadInternal().

loadHelper() [3/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 1121 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [4/10]

template<typename P >

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

inline

Optional helper routine.

Definition at line 1137 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 1113 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [6/10]

template<typename P >

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

inline

Shared Pointer helper routine.

Definition at line 1097 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [7/10]

template<typename P >

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

inline

Unique Pointer helper routine.

Definition at line 1105 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [8/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 1129 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [9/10]

template<typename P >

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

inline

Vector helper routine.

Definition at line 1089 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 1159 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 , typename Q >

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

inline

HashMap helper routine.

Definition at line 1053 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [2/10]

template<typename P >

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

inline

Scalar helper routine.

Definition at line 989 of file DataIO.h.

{
  dataStore(stream, data, context);
}

Referenced by dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), MaterialPropertyBase< T, is_ad >::store(), RestartableData< T >::storeInternal(), and ReporterState< T >::storeInternal().

storeHelper() [3/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 1029 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [4/10]

template<typename P >

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

inline

Optional helper routine.

Definition at line 1045 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 1021 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [6/10]

template<typename P >

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

inline

Shared pointer helper routine.

Definition at line 1005 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [7/10]

template<typename P >

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

inline

Unique pointer helper routine.

Definition at line 1013 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [8/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 1037 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [9/10]

template<typename P >

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

inline

Vector helper routine.

Definition at line 997 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 1066 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);
  }
}