Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it. More...

#include <RestartableEquationSystems.h>

Classes
struct	EquationSystemsHeader
	Represents a stored EquationSystems in restart. More...

struct	SystemHeader
	Represents a stored system in restart. More...

struct	VariableHeader
	Represents a stored variable in restart. More...

struct	VectorHeader
	Represents a stored variable in restart. More...

Public Member Functions
	RestartableEquationSystems (libMesh::MeshBase &mesh)

void	store (std::ostream &stream) const
	Stores the EquationSystems to the given stream. More...

void	load (std::istream &stream)
	Loads the EquationSystems from the given stream. More...

void	setLoadAllVectors (const bool load_all_vectors)
	Sets whether or not all vectors are to be loaded. More...


libMesh::EquationSystems &	es ()

const libMesh::EquationSystems &	es () const

Private Member Functions
EquationSystemsHeader	buildHeader (const std::vector< const libMesh::DofObject *> &ordered_objects) const
	Internal method for building the header struct. More...

std::vector< const libMesh::DofObject * >	orderDofObjects () const
	Internal method for ordering the DofObjects by ID (elems and the nodes) More...

void	restore (const SystemHeader &from_sys_header, const VectorHeader &from_vec_header, const VariableHeader &from_var_header, const libMesh::System &to_sys, libMesh::NumericVector< libMesh::Number > &to_vec, const libMesh::Variable &to_var, std::istream &stream)

Private Attributes
libMesh::EquationSystems	_es
	The underlying EquationSystems. More...

bool	_load_all_vectors
	Whether or not to load all of the vectors, including ones that haven't been added yet. More...

std::size_t	_loaded_stream_data_begin
	The starting position for the vector data in the input stream. More...

std::vector< const libMesh::DofObject * >	_loaded_ordered_objects
	The object ordering for this data. More...

EquationSystemsHeader	_loaded_header
	The loaded header. More...

Detailed Description

Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it.

Definition at line 31 of file RestartableEquationSystems.h.

Constructor & Destructor Documentation

◆ RestartableEquationSystems()

RestartableEquationSystems::RestartableEquationSystems ( libMesh::MeshBase & mesh )

Definition at line 22 of file RestartableEquationSystems.C.

   : _es(mesh), _load_all_vectors(true)
 {
 }

Member Function Documentation

◆ buildHeader()

RestartableEquationSystems::EquationSystemsHeader RestartableEquationSystems::buildHeader ( const std::vector< const libMesh::DofObject *> & ordered_objects ) const

private

Internal method for building the header struct.

Definition at line 28 of file RestartableEquationSystems.C.

Referenced by store().

 {
   EquationSystemsHeader es_header;
 
   // Systems
   for (const auto sys_num : make_range(_es.n_systems()))
   {
     const auto & sys = _es.get_system(sys_num);
 
     SystemHeader sys_header;
     sys_header.name = sys.name();
     sys_header.type = sys.system_type();
 
     // Variables in the system
     for (const auto var_num : make_range(sys.n_vars()))
     {
       const auto & var = sys.variable(var_num);
 
       VariableHeader var_header;
       var_header.name = var.name();
       var_header.type = var.type();
       var_header.size = 0;
       var_header.variable = &var;
 
       mooseAssert(_es.comm().verify("sys_" + sys.name() + "_var_" + var.name()),
                   "Out of order in parallel");
       mooseAssert(!sys_header.variables.count(var.name()), "Already inserted");
 
       // Non-SCALAR variable
       if (var.type().family != SCALAR)
       {
         for (const auto & obj : ordered_objects)
           var_header.size += sizeof(Real) * obj->n_comp(sys.number(), var.number());
       }
       // SCALAR variable on the last rank
       else if (_es.processor_id() == _es.n_processors() - 1)
       {
         std::vector<dof_id_type> scalar_dofs;
         sys.get_dof_map().SCALAR_dof_indices(scalar_dofs, var.number());
         var_header.size += sizeof(Real) * scalar_dofs.size();
       }
 
       sys_header.variables.emplace(var.name(), var_header);
     }
 
     // System vector
     auto & sys_vec_header = sys_header.vectors[SystemHeader::system_solution_name];
     sys_vec_header.name = SystemHeader::system_solution_name;
     sys_vec_header.vector = sys.solution.get();
     sys_vec_header.type = sys_vec_header.vector->type();
     for (const auto vec_num : make_range(sys.n_vectors()))
     {
       mooseAssert(_es.comm().verify("sys_" + sys.name() + "_vec_" + sys.vector_name(vec_num)),
                   "Out of order in parallel");
       const auto & name = sys.vector_name(vec_num);
       mooseAssert(!sys_header.vectors.count(name), "Already inserted");
       auto & vec_header = sys_header.vectors[name];
       vec_header.name = sys.vector_name(vec_num);
       vec_header.projections = sys.vector_preservation(vec_header.name);
       vec_header.vector = &sys.get_vector(vec_header.name);
       vec_header.type = vec_header.vector->type();
     }
 
     // System in this EquationSystems
     mooseAssert(!es_header.systems.count(sys.name()), "Already inserted");
     es_header.systems.emplace(sys.name(), sys_header);
   }
 
   // Setup the positions in each vector for easy access later
   std::size_t offset = 0;
   for (auto & sys_name_header_pair : es_header.systems)
   {
     auto & sys_header = sys_name_header_pair.second;
     for (auto & vec_name_header_pair : sys_header.vectors)
     {
       auto & vec_header = vec_name_header_pair.second;
       for (const auto & var_name_header_pair : sys_header.variables)
       {
         const auto & var_header = var_name_header_pair.second;
         mooseAssert(!vec_header.variable_offset.count(var_header.name), "Already inserted");
         vec_header.variable_offset[var_header.name] = offset;
         offset += var_header.size;
       }
     }
   }
 
   es_header.data_size = offset;
 
   return es_header;
 }

◆ es() [1/2]

libMesh::EquationSystems& RestartableEquationSystems::es ( )

inline

Returns: The underyling EquationSystems

Definition at line 129 of file RestartableEquationSystems.h.

Referenced by FEProblemBase::es().

129 { return _es; }

RestartableEquationSystems::_es

libMesh::EquationSystems _es

The underlying EquationSystems.

Definition: RestartableEquationSystems.h:162

◆ es() [2/2]

const libMesh::EquationSystems& RestartableEquationSystems::es ( ) const

inline

Definition at line 130 of file RestartableEquationSystems.h.

130 { return _es; }

RestartableEquationSystems::_es

libMesh::EquationSystems _es

The underlying EquationSystems.

Definition: RestartableEquationSystems.h:162

◆ load()

void RestartableEquationSystems::load ( std::istream & stream )

Loads the EquationSystems from the given stream.

Definition at line 223 of file RestartableEquationSystems.C.

Referenced by dataLoad().

 {
   // Load the header (systems, variables, vectors)
   // We do this first so that the loader can make informed decisions
   // on what to put where based on everything that is available
   _loaded_header.systems.clear();
   dataLoad(stream, _loaded_header, nullptr);
 
   // Order objects (elements and then node) by ID for storing
   _loaded_ordered_objects = orderDofObjects();
 
   // Sanity check on if we're loading the same thing
   {
     std::vector<dof_id_type> from_ordered_objects_ids;
     dataLoad(stream, from_ordered_objects_ids, nullptr);
     if (_loaded_ordered_objects.size() != from_ordered_objects_ids.size())
       mooseError("RestartableEquationSystems::load(): Number of previously stored elements/nodes (",
                  _loaded_ordered_objects.size(),
                  ") does not "
                  "match the current number of elements/nodes (",
                  from_ordered_objects_ids.size(),
                  ")");
     for (const auto i : index_range(_loaded_ordered_objects))
       if (_loaded_ordered_objects[i]->id() != from_ordered_objects_ids[i])
         mooseError("RestartableEquationSystems::load(): Id of previously stored element/node (",
                    _loaded_ordered_objects[i]->id(),
                    ") does not "
                    "match the current element/node id (",
                    from_ordered_objects_ids[i],
                    ")");
   }
 
   _loaded_stream_data_begin = static_cast<std::size_t>(stream.tellg());
 
   // Load everything that we have available at the moment
   for (const auto & sys_name_header_pair : _loaded_header.systems)
   {
     const auto & sys_header = sys_name_header_pair.second;
     if (!_es.has_system(sys_header.name))
       continue;
     auto & sys = _es.get_system(sys_header.name);
 
     bool modified_sys = false;
 
     for (const auto & vec_name_header_pair : sys_header.vectors)
     {
       bool modified_vec = false;
 
       const auto & vec_header = vec_name_header_pair.second;
       const bool is_solution = vec_header.name == SystemHeader::system_solution_name;
 
       if (!is_solution && !sys.have_vector(vec_header.name))
       {
         if (_load_all_vectors)
           sys.add_vector(vec_header.name, vec_header.projections, vec_header.type);
         else
           continue;
       }
 
       auto & vec = is_solution ? *sys.solution : sys.get_vector(vec_header.name);
 
       for (const auto & var_name_header_pair : sys_header.variables)
       {
         const auto & var_header = var_name_header_pair.second;
         if (!sys.has_variable(var_header.name))
           continue;
         const auto & var = sys.variable(sys.variable_number(var_header.name));
         if (var.type() != var_header.type)
           continue;
 
         restore(sys_header, vec_header, var_header, sys, vec, var, stream);
         modified_vec = true;
       }
 
       if (modified_vec)
       {
         vec.close();
         modified_sys = true;
       }
     }
 
     if (modified_sys)
       sys.update();
   }
 
   // Move the stream to the end of our data so that we make RestartableDataReader happy
   stream.seekg(_loaded_stream_data_begin + _loaded_header.data_size);
 }

◆ orderDofObjects()

std::vector< const libMesh::DofObject * > RestartableEquationSystems::orderDofObjects ( ) const

private

Internal method for ordering the DofObjects by ID (elems and the nodes)

Definition at line 121 of file RestartableEquationSystems.C.

Referenced by load(), and store().

 {
   std::vector<const libMesh::DofObject *> objects;
   auto add = [&objects](const auto begin, const auto end)
   {
     std::set<const libMesh::DofObject *, libMesh::CompareDofObjectsByID> ordered(begin, end);
     objects.insert(objects.end(), ordered.begin(), ordered.end());
   };
 
   const auto & mesh = _es.get_mesh();
   add(mesh.local_elements_begin(), mesh.local_elements_end());
   add(mesh.local_nodes_begin(), mesh.local_nodes_end());
 
   return objects;
 }

◆ restore()

void RestartableEquationSystems::restore	(	const SystemHeader &	from_sys_header,
		const VectorHeader &	from_vec_header,
		const VariableHeader &	from_var_header,
		const libMesh::System &	to_sys,
		libMesh::NumericVector< libMesh::Number > &	to_vec,
		const libMesh::Variable &	to_var,
		std::istream &	stream
	)

private

Definition at line 313 of file RestartableEquationSystems.C.

Referenced by load().

 {
 #ifndef NDEBUG
   const auto sys_it = _loaded_header.systems.find(from_sys_header.name);
   mooseAssert(sys_it != _loaded_header.systems.end(), "System does not exist");
   const auto & sys_header = sys_it->second;
   mooseAssert(sys_header == from_sys_header, "Not my system");
   const auto vec_it = sys_header.vectors.find(from_vec_header.name);
   mooseAssert(vec_it != sys_header.vectors.end(), "Vector does not exist");
   const auto & vec_header = vec_it->second;
   mooseAssert(vec_header == from_vec_header, "Not my vector");
   const auto var_it = sys_header.variables.find(from_var_header.name);
   mooseAssert(var_it != sys_header.variables.end(), "Variable does not exist");
   const auto & var_header = var_it->second;
   mooseAssert(var_header == from_var_header, "Not my variable");
 #endif
 
   const auto error =
       [&from_sys_header, &from_vec_header, &from_var_header, &to_sys, &to_var](auto... args)
   {
     mooseError("An error occured while restoring a system:\n",
                args...,
                "\n\nFrom system: ",
                from_sys_header.name,
                "\nFrom vector: ",
                from_vec_header.name,
                "\nFrom variable: ",
                from_var_header.name,
                "\nTo system: ",
                to_sys.name(),
                "\nTo variable: ",
                to_var.name());
   };
 
   if (from_var_header.type != to_var.type())
     error("Cannot restore to a variable of a different type");
 
   const auto offset = from_vec_header.variable_offset.at(from_var_header.name);
   stream.seekg(_loaded_stream_data_begin + offset);
 
   // Non-SCALAR variable
   if (to_var.type().family != SCALAR)
   {
     for (const auto & obj : _loaded_ordered_objects)
       for (const auto comp : make_range(obj->n_comp(to_sys.number(), to_var.number())))
       {
         Real val;
         dataLoad(stream, val, nullptr);
         to_vec.set(obj->dof_number(to_sys.number(), to_var.number(), comp), val);
       }
   }
   // SCALAR variable on the last rank
   else if (_es.processor_id() == _es.n_processors() - 1)
   {
     const auto & dof_map = to_sys.get_dof_map();
     std::vector<dof_id_type> scalar_dofs;
     dof_map.SCALAR_dof_indices(scalar_dofs, to_var.number());
     for (const auto dof : scalar_dofs)
     {
       Real val;
       dataLoad(stream, val, nullptr);
       to_vec.set(dof, val);
     }
   }
 }

◆ setLoadAllVectors()

void RestartableEquationSystems::setLoadAllVectors ( const bool load_all_vectors )

inline

Sets whether or not all vectors are to be loaded.

By default, this is true. This means that all vectors that do not currently exist in the system will be added and loaded.

Typically, we would want this to be false in the case of restart.

Definition at line 143 of file RestartableEquationSystems.h.

Referenced by FEProblemBase::initialSetup().

143 { _load_all_vectors = load_all_vectors; }

RestartableEquationSystems::_load_all_vectors

bool _load_all_vectors

Whether or not to load all of the vectors, including ones that haven't been added yet...

Definition: RestartableEquationSystems.h:165

◆ store()

void RestartableEquationSystems::store ( std::ostream & stream ) const

Stores the EquationSystems to the given stream.

Definition at line 138 of file RestartableEquationSystems.C.

Referenced by dataStore().

 {
   // Order objects (elements and then nodes) by ID for storing
   const auto ordered_objects = orderDofObjects();
 
   // Store the header (systems, variables, vectors)
   EquationSystemsHeader es_header = buildHeader(ordered_objects);
   dataStore(stream, es_header, nullptr);
 
   // Store the ordered objects so we can do a sanity check on if we're
   // loading the same thing
   {
     std::vector<dof_id_type> ordered_objects_ids(ordered_objects.size());
     for (const auto i : index_range(ordered_objects))
       ordered_objects_ids[i] = ordered_objects[i]->id();
     dataStore(stream, ordered_objects_ids, nullptr);
   }
 
 #ifndef NDEBUG
   const std::size_t data_initial_position = static_cast<std::size_t>(stream.tellp());
 #endif
 
   // Store each system
   for (const auto & sys_name_header_pair : es_header.systems)
   {
     const auto & sys_header = sys_name_header_pair.second;
     const auto & sys = _es.get_system(sys_header.name);
 
     // Store each vector and variable
     for (const auto & vec_name_header_pair : sys_header.vectors)
     {
       const auto & vec_header = vec_name_header_pair.second;
       const auto & vec = *vec_header.vector;
       for (const auto & var_name_header_pair : sys_header.variables)
       {
         const auto & var_header = var_name_header_pair.second;
         const auto & var = *var_header.variable;
 
 #ifndef NDEBUG
         const std::size_t var_initial_position = stream.tellp();
 #endif
 
         // Non-SCALAR variable
         if (var.type().family != SCALAR)
         {
           // Store for each component of each element and node
           for (const auto & obj : ordered_objects)
             for (const auto comp : make_range(obj->n_comp(sys.number(), var.number())))
             {
               auto val = vec(obj->dof_number(sys.number(), var.number(), comp));
               dataStore(stream, val, nullptr);
             }
         }
         // SCALAR variable on the last rank
         else if (_es.processor_id() == _es.n_processors() - 1)
         {
           const auto & dof_map = sys.get_dof_map();
           std::vector<dof_id_type> scalar_dofs;
           dof_map.SCALAR_dof_indices(scalar_dofs, var.number());
           for (const auto dof : scalar_dofs)
           {
             auto val = vec(dof);
             dataStore(stream, val, nullptr);
           }
         }
 
 #ifndef NDEBUG
         const std::size_t data_offset = var_initial_position - data_initial_position;
         mooseAssert(vec_header.variable_offset.at(var_header.name) == data_offset,
                     "Invalid offset");
 
         const std::size_t current_position = static_cast<std::size_t>(stream.tellp());
         const std::size_t var_size = current_position - var_initial_position;
         mooseAssert(var_size == sys_header.variables.at(var.name()).size, "Incorrect assumed size");
 #endif
       }
     }
   }
 
   mooseAssert((data_initial_position + es_header.data_size) ==
                   static_cast<std::size_t>(stream.tellp()),
               "Incorrect assumed size");
 }