DataIO.C File Reference

Go to the source code of this file.

Functions
template<>
void	dataStore (std::ostream &stream, Real &v, void *)
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, bool &v, void *)
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, DualReal &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, RealEigenVector &v, void *context)
template<>
void	dataStore (std::ostream &stream, RealEigenMatrix &v, 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< DualReal > &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< DualReal > &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< DualReal > &v, void *context)
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)
	Stores an owned numeric vector. More...
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 *context)
template<>
void	dataLoad (std::istream &stream, bool &v, void *)
template<>
void	dataLoad (std::istream &stream, std::vector< bool > &v, void *context)
template<>
void	dataLoad (std::istream &stream, DualReal &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, RealEigenVector &v, void *context)
template<>
void	dataLoad (std::istream &stream, RealEigenMatrix &v, 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< DualReal > &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< DualReal > &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< DualReal > &v, void *context)
void	dataLoad (std::istream &stream, Point &p, 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)
	Loads an owned numeric vector. More...
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,
		Real &	v,
		void *
	)

Definition at line 357 of file DataIO.C.

Referenced by dataLoad().

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

dataLoad() [2/26]

template<>

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

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

template<>

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

Definition at line 379 of file DataIO.C.

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

dataLoad() [4/26]

template<>

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

Definition at line 387 of file DataIO.C.

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

dataLoad() [5/26]

template<>

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

Definition at line 394 of file DataIO.C.

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

dataLoad() [6/26]

template<>

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

Definition at line 402 of file DataIO.C.

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

  if (DualReal::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() [7/26]

template<>

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

Definition at line 423 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;

  loadHelper(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,
		const Node *&	n,
		void *	context
	)

Definition at line 443 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;

  loadHelper(stream, id, context);

  if (id != libMesh::DofObject::invalid_id)
    n = mesh->nodePtr(id);
  else
    n = NULL;
}

dataLoad() [9/26]

template<>

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

Definition at line 463 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;

  loadHelper(stream, id, context);

  if (id != libMesh::DofObject::invalid_id)
    e = mesh->elemPtr(id);
  else
    e = NULL;
}

dataLoad() [10/26]

template<>

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

Definition at line 483 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;

  loadHelper(stream, id, context);

  if (id != libMesh::DofObject::invalid_id)
    n = mesh->nodePtr(id);
  else
    n = NULL;
}

dataLoad() [11/26]

template<>

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

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

template<>

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

Definition at line 518 of file DataIO.C.

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

dataLoad() [13/26]

template<>

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

Definition at line 533 of file DataIO.C.

{
  unsigned int m = 0;
  stream.read((char *)&m, sizeof(m));
  unsigned int n = 0;
  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++)
    {
      Real r = 0;
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [14/26]

template<typename T >

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

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

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

dataLoad() [16/26]

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

dataLoad() [17/26]

template<typename T >

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

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

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

dataLoad() [19/26]

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

dataLoad() [20/26]

template<typename T >

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

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

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

dataLoad() [22/26]

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

dataLoad() [23/26]

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

Definition at line 605 of file DataIO.C.

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

dataLoad() [24/26]

template<>

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

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

template<>

void dataLoad	(	std::istream &	stream,
		std::unique_ptr< libMesh::NumericVector< 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.

Definition at line 655 of file DataIO.C.

{
  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() [26/26]

template<>

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

Definition at line 698 of file DataIO.C.

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

  VecRestoreArray(v, &array);
}

dataStore() [1/29]

template<>

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

Definition at line 28 of file DataIO.C.

Referenced by dataStore().

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

dataStore() [2/29]

template<>

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

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

template<>

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

Definition at line 47 of file DataIO.C.

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

dataStore() [4/29]

template<>

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

Definition at line 55 of file DataIO.C.

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

dataStore() [5/29]

template<>

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

Definition at line 62 of file DataIO.C.

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

dataStore() [6/29]

template<>

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

Definition at line 70 of file DataIO.C.

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

dataStore() [7/29]

template<>

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

Definition at line 77 of file DataIO.C.

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

dataStore() [8/29]

template<>

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

Definition at line 84 of file DataIO.C.

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

dataStore() [9/29]

template<>

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

Definition at line 91 of file DataIO.C.

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

  if (DualReal::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() [10/29]

template<>

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

Definition at line 110 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!");
  }

  storeHelper(stream, id, context);
}

dataStore() [11/29]

template<>

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

Definition at line 127 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!");
  }

  storeHelper(stream, id, context);
}

dataStore() [12/29]

template<>

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

Definition at line 144 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!");
  }

  storeHelper(stream, id, context);
}

dataStore() [13/29]

template<>

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

Definition at line 161 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!");
  }

  storeHelper(stream, id, context);
}

dataStore() [14/29]

template<>

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

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

template<>

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

Definition at line 190 of file DataIO.C.

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

dataStore() [16/29]

template<>

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

Definition at line 203 of file DataIO.C.

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

dataStore() [17/29]

template<typename T >

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

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

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

dataStore() [19/29]

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

dataStore() [20/29]

template<typename T >

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

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

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

dataStore() [22/29]

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

dataStore() [23/29]

template<typename T >

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

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

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

dataStore() [25/29]

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

dataStore() [26/29]

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

Definition at line 268 of file DataIO.C.

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

dataStore() [27/29]

template<>

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

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

template<>

void dataStore	(	std::ostream &	stream,
		std::unique_ptr< libMesh::NumericVector< 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.

Definition at line 318 of file DataIO.C.

{
  mooseAssert(v, "Null vector");
  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 = 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() [29/29]

template<>

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

Definition at line 712 of file DataIO.C.

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

  VecRestoreArray(v, &array);
}