DataIO.C File Reference

Go to the source code of this file.

Functions
template<>
void	dataStore< mt_state > (std::ostream &stream, mt_state &foo, void *ctx)
template<>
void	dataStore (std::ostream &stream, std::string &v, void *)
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, FEType &v, void *context)
template<>
void	dataStore (std::ostream &stream, std::vector< bool > &v, void *context)
template<>
void	dataStore (std::ostream &stream, RankTwoTensor &rtt, void *context)
template<>
void	dataStore (std::ostream &stream, RankThreeTensor &rtht, void *context)
template<>
void	dataStore (std::ostream &stream, RankFourTensor &rft, void *context)
template<>
void	dataStore (std::ostream &stream, ADReal &dn, 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 *)
template<>
void	dataStore (std::ostream &stream, torch::Tensor &t, void *context)
template<typename T >
void	dataStore (std::ostream &stream, TensorValue< T > &v, void *context)
template void	dataStore (std::ostream &stream, TensorValue< Real > &v, void *context)
template void	dataStore (std::ostream &stream, TensorValue< ADReal > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, DenseMatrix< T > &v, void *context)
template void	dataStore (std::ostream &stream, DenseMatrix< Real > &v, void *context)
template void	dataStore (std::ostream &stream, DenseMatrix< ADReal > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, VectorValue< T > &v, void *context)
template void	dataStore (std::ostream &stream, VectorValue< Real > &v, void *context)
template void	dataStore (std::ostream &stream, VectorValue< ADReal > &v, void *context)
template<>
void	dataStore (std::ostream &stream, const Point &p, void *context)
void	dataStore (std::ostream &stream, libMesh::BoundingBox &bbox, void *context)
template<>
void	dataStore (std::ostream &stream, Point &p, void *context)
template<>
void	dataStore (std::ostream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataStore (std::ostream &stream, std::unique_ptr< libMesh::NumericVector< Number > > &v, void *context)
template<>
void	dataLoad< mt_state > (std::istream &stream, mt_state &foo, void *ctx)
template<>
void	dataLoad (std::istream &stream, std::string &v, void *)
template<>
void	dataLoad (std::istream &stream, VariableName &v, void *context)
template<>
void	dataLoad (std::istream &stream, UserObjectName &v, void *context)
template<>
void	dataLoad (std::istream &stream, FEType &v, void *context)
template<>
void	dataLoad (std::istream &stream, std::vector< bool > &v, void *context)
template<>
void	dataLoad (std::istream &stream, ADReal &dn, void *context)
template<>
void	dataLoad (std::istream &stream, const Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, const Node *&n, void *context)
template<>
void	dataLoad (std::istream &stream, Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, Node *&n, void *context)
template<>
void	dataLoad (std::istream &stream, std::stringstream &s, void *)
template<>
void	dataLoad (std::istream &stream, torch::Tensor &t, void *context)
template<typename T >
void	dataLoad (std::istream &stream, TensorValue< T > &v, void *context)
template void	dataLoad (std::istream &stream, TensorValue< Real > &v, void *context)
template void	dataLoad (std::istream &stream, TensorValue< ADReal > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, DenseMatrix< T > &v, void *context)
template void	dataLoad (std::istream &stream, DenseMatrix< Real > &v, void *context)
template void	dataLoad (std::istream &stream, DenseMatrix< ADReal > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, VectorValue< T > &v, void *context)
template void	dataLoad (std::istream &stream, VectorValue< Real > &v, void *context)
template void	dataLoad (std::istream &stream, VectorValue< ADReal > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Point &p, void *context)
void	dataLoad (std::istream &stream, libMesh::BoundingBox &bbox, void *context)
template<>
void	dataLoad (std::istream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataLoad (std::istream &stream, std::unique_ptr< libMesh::NumericVector< Number > > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Vec &v, void *context)
template<>
void	dataStore (std::ostream &stream, Vec &v, void *context)

Function Documentation

dataLoad() [1/26]

template<>

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

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

template<>

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

Definition at line 509 of file DataIO.C.

{
  if (!context)
    mooseError("Can only load Elem objects using a MooseMesh context!");
 
  MooseMesh * mesh = static_cast<MooseMesh *>(context);
 
  // TODO: Write out the unique ID of this element
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  dataLoad(stream, id, context);
 
  if (id != libMesh::DofObject::invalid_id)
    e = mesh->elemPtr(id);
  else
    e = NULL;
}

dataLoad() [3/26]

template<>

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

Definition at line 529 of file DataIO.C.

{
  if (!context)
    mooseError("Can only load Node objects using a MooseMesh context!");
 
  MooseMesh * mesh = static_cast<MooseMesh *>(context);
 
  // TODO: Write out the unique ID of this nodeent
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  dataLoad(stream, id, context);
 
  if (id != libMesh::DofObject::invalid_id)
    n = mesh->nodePtr(id);
  else
    n = NULL;
}

dataLoad() [4/26]

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

dataLoad() [5/26]

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

dataLoad() [6/26]

template<typename T >

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

Definition at line 658 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() [7/26]

template<>

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

Definition at line 549 of file DataIO.C.

{
  if (!context)
    mooseError("Can only load Elem objects using a MooseMesh context!");
 
  MooseMesh * mesh = static_cast<MooseMesh *>(context);
 
  // TODO: Write out the unique ID of this element
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  dataLoad(stream, id, context);
 
  if (id != libMesh::DofObject::invalid_id)
    e = mesh->elemPtr(id);
  else
    e = NULL;
}

dataLoad() [8/26]

template<>

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

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

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

Definition at line 702 of file DataIO.C.

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

dataLoad() [10/26]

template<>

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

Definition at line 709 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;
    dataLoad(stream, key, context);
    dataLoad(stream, type, context);
 
#define loadscalar(ptype)                                                                          \
  else if (type == demangle(typeid(ptype).name())) do                                              \
  {                                                                                                \
    ptype & value = p.set<ptype>(key);                                                             \
    dataLoad(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() [11/26]

template<>

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

Definition at line 569 of file DataIO.C.

{
  if (!context)
    mooseError("Can only load Node objects using a MooseMesh context!");
 
  MooseMesh * mesh = static_cast<MooseMesh *>(context);
 
  // TODO: Write out the unique ID of this nodeent
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  dataLoad(stream, id, context);
 
  if (id != libMesh::DofObject::invalid_id)
    n = mesh->nodePtr(id);
  else
    n = NULL;
}

dataLoad() [12/26]

template<>

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

Definition at line 695 of file DataIO.C.

{
  for (const auto i : make_range(Moose::dim))
    dataLoad(stream, p(i), context);
}

dataLoad() [13/26]

template<>

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

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

Referenced by dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), dataLoad(), and dataLoad< mt_state >().

dataLoad() [14/26]

template<>

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

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

template<>

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

Definition at line 747 of file DataIO.C.

{
  bool have_vector;
  dataLoad(stream, have_vector, context);
 
  if (!have_vector)
    return;
 
  mooseAssert(context, "Needs a context of the communicator");
  const auto & comm = *static_cast<const libMesh::Parallel::Communicator *>(context);
  if (v)
    mooseAssert(&comm == &v->comm(), "Inconsistent communicator");
 
  // Load the communicator size for consistency checks
  unsigned int comm_size;
  dataLoad(stream, comm_size, nullptr);
  mooseAssert(comm.size() == comm_size, "Inconsistent communicator size");
 
  // Load the solver package to build the vector
  int solver_package_int;
  dataLoad(stream, solver_package_int, nullptr);
  libMesh::SolverPackage solver_package = static_cast<libMesh::SolverPackage>(solver_package_int);
 
  // Load the sizes
  dof_id_type size, local_size;
  dataLoad(stream, size, nullptr);
  dataLoad(stream, local_size, nullptr);
 
  // Construct the vector given the type, only if we need to. v could be non-null here
  // if we're advancing back and loading a backup
  if (!v)
  {
    v = NumericVector<Number>::build(comm, solver_package);
    v->init(size, local_size);
  }
  else
    mooseAssert(v->type() != GHOSTED, "Cannot be ghosted");
 
  // Make sure that the sizes are consistent; this will happen if we're calling this
  // on a vector that has already been loaded previously
  mooseAssert(v->size() == size, "Inconsistent size");
  mooseAssert(v->local_size() == local_size, "Inconsistent local size");
 
  // Now that we have an initialized vector, fill the entries
  dataLoad(stream, *v, nullptr);
}

dataLoad() [16/26]

template<>

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

Definition at line 473 of file DataIO.C.

{
  std::size_t size = 0;
  dataLoad(stream, size, nullptr);
  v.resize(size);
  for (std::size_t i = 0; i < size; i++)
  {
    bool b;
    dataLoad(stream, b, context);
    v[i] = b;
  }
}

dataLoad() [17/26]

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

dataLoad() [18/26]

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

dataLoad() [19/26]

template<typename T >

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

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

template<>

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

Definition at line 605 of file DataIO.C.

{
  bool defined = false;
  dataLoad(stream, defined, nullptr);
  if (!defined)
  {
    t = torch::Tensor(); // undefined tensor
    return;
  }
 
  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() [21/26]

template<>

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

Definition at line 443 of file DataIO.C.

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

dataLoad() [22/26]

template<>

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

Definition at line 435 of file DataIO.C.

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

dataLoad() [23/26]

template<>

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

Definition at line 796 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() [24/26]

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

dataLoad() [25/26]

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

dataLoad() [26/26]

template<typename T >

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

Definition at line 678 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< mt_state >()

template<>

void dataLoad< mt_state >	(	std::istream &	stream,
		mt_state &	foo,
		void *	ctx
	)

Definition at line 410 of file DataIO.C.

{
  dataLoad(stream, foo.statevec, ctx);
  dataLoad(stream, foo.stateptr, ctx);
  dataLoad(stream, foo.initialized, ctx);
}

dataStore() [1/30]

template<>

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

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

template<>

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

Definition at line 142 of file DataIO.C.

{
  // TODO: Write out the unique ID of this elem
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  if (e)
  {
    id = e->id();
    if (id == libMesh::DofObject::invalid_id)
      mooseError("Can't output Elems with invalid ids!");
  }
 
  dataStore(stream, id, context);
}

dataStore() [3/30]

template<>

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

Definition at line 159 of file DataIO.C.

{
  // TODO: Write out the unique ID of this node
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  if (n)
  {
    id = n->id();
    if (id == libMesh::DofObject::invalid_id)
      mooseError("Can't output Nodes with invalid ids!");
  }
 
  dataStore(stream, id, context);
}

dataStore() [4/30]

template<>

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

Definition at line 305 of file DataIO.C.

{
  for (const auto i : make_range(Moose::dim))
    dataStore(stream, p(i), context);
}

dataStore() [5/30]

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

dataStore() [6/30]

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

dataStore() [7/30]

template<typename T >

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

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

template<>

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

Definition at line 176 of file DataIO.C.

{
  // TODO: Write out the unique ID of this elem
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  if (e)
  {
    id = e->id();
    if (id == libMesh::DofObject::invalid_id)
      mooseError("Can't output Elems with invalid ids!");
  }
 
  dataStore(stream, id, context);
}

dataStore() [9/30]

template<>

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

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

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

Definition at line 312 of file DataIO.C.

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

dataStore() [11/30]

template<>

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

Definition at line 326 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();
 
    dataStore(stream, key, context);
    dataStore(stream, type, context);
 
#define storescalar(ptype)                                                                         \
  else if (it->second->type() == demangle(typeid(ptype).name())) dataStore(                        \
      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() [12/30]

template<>

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

Definition at line 193 of file DataIO.C.

{
  // TODO: Write out the unique ID of this node
  dof_id_type id = libMesh::DofObject::invalid_id;
 
  if (n)
  {
    id = n->id();
    if (id == libMesh::DofObject::invalid_id)
      mooseError("Can't output Nodes with invalid ids!");
  }
 
  dataStore(stream, id, context);
}

dataStore() [13/30]

template<>

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

Definition at line 319 of file DataIO.C.

{
  dataStore(stream, const_cast<const Point &>(p), context);
}

dataStore() [14/30]

template<>

void dataStore	(	std::ostream &	stream,
		RankFourTensor &	rft,
		void *	context
	)

Definition at line 116 of file DataIO.C.

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

dataStore() [15/30]

template<>

void dataStore	(	std::ostream &	stream,
		RankThreeTensor &	rtht,
		void *	context
	)

Definition at line 109 of file DataIO.C.

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

dataStore() [16/30]

template<>

void dataStore	(	std::ostream &	stream,
		RankTwoTensor &	rtt,
		void *	context
	)

Definition at line 102 of file DataIO.C.

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

dataStore() [17/30]

template<>

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

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

Referenced by dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), dataStore(), and dataStore< mt_state >().

dataStore() [18/30]

template<>

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

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

template<>

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

Definition at line 365 of file DataIO.C.

{
  // Classes may declare unique pointers to vectors as restartable data and never actually create
  // vector instances. This happens for example in the `TimeIntegrator` class where subvector
  // instances are only created if multiple time integrators are present
  bool have_vector = v.get();
  dataStore(stream, have_vector, context);
  if (!have_vector)
    return;
 
  mooseAssert(context, "Needs a context of the communicator");
  const auto & comm = *static_cast<const libMesh::Parallel::Communicator *>(context);
  mooseAssert(&comm == &v->comm(), "Inconsistent communicator");
 
  if (v->type() == GHOSTED)
    mooseError("Cannot store ghosted numeric vectors");
 
  // Store the communicator size for sanity checking later
  unsigned int comm_size = comm.size();
  dataStore(stream, comm_size, nullptr);
 
  // Store the solver package so that we know what vector type to construct
  libMesh::SolverPackage solver_package;
  if (dynamic_cast<libMesh::PetscVector<Number> *>(v.get()))
    solver_package = libMesh::PETSC_SOLVERS;
  else
    mooseError("Can only store unique_ptrs of PetscVectors");
  int solver_package_int = solver_package;
  dataStore(stream, solver_package_int, nullptr);
 
  // Store the sizes
  dof_id_type size = v->size();
  dataStore(stream, size, nullptr);
  dof_id_type local_size = v->local_size();
  dataStore(stream, local_size, nullptr);
 
  // Store the vector itself
  dataStore(stream, *v, nullptr);
}

dataStore() [20/30]

template<>

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

Definition at line 92 of file DataIO.C.

{
  std::size_t size = v.size();
  dataStore(stream, size, nullptr);
  for (bool b : v)
    dataStore(stream, b, context);
}

dataStore() [21/30]

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

dataStore() [22/30]

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

dataStore() [23/30]

template<typename T >

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

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

template<>

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

Definition at line 223 of file DataIO.C.

{
  const bool defined = t.defined();
  dataStore(stream, defined, nullptr);
 
  if (!defined)
    return;
 
  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() [25/30]

template<>

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

Definition at line 59 of file DataIO.C.

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

dataStore() [26/30]

template<>

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

Definition at line 51 of file DataIO.C.

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

dataStore() [27/30]

template<>

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

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

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

dataStore() [29/30]

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

dataStore() [30/30]

template<typename T >

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

Definition at line 289 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< mt_state >()

template<>

void dataStore< mt_state >	(	std::ostream &	stream,
		mt_state &	foo,
		void *	ctx
	)

Definition at line 29 of file DataIO.C.

{
  dataStore(stream, foo.statevec, ctx);
  dataStore(stream, foo.stateptr, ctx);
  dataStore(stream, foo.initialized, ctx);
}