RestartableEquationSystems.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include <set>
#include <string>
#include <unordered_map>
#include <iostream>
 
#include "libmesh/enum_order.h"
#include "libmesh/fe_type.h"
#include "libmesh/equation_systems.h"
#include "nlohmann/json.h"
 
namespace libMesh
{
class DofObject;
class EquationSystems;
class MeshBase;
}
 
class RestartableEquationSystems
{
public:
  RestartableEquationSystems(libMesh::MeshBase & mesh);
 
  struct VectorHeader
  {
    bool operator==(const VectorHeader & other) const
    {
      return name == other.name && projections == other.projections &&
             variable_offset == other.variable_offset && vector == other.vector;
    }
 
    std::string name;
    libMesh::ParallelType type;
    bool projections;
    std::map<std::string, std::size_t> variable_offset;
    const libMesh::NumericVector<libMesh::Number> * vector = nullptr;
  };
 
  struct VariableHeader
  {
    bool operator==(const VariableHeader & other) const
    {
      return name == other.name && type == other.type && size == other.size &&
             variable == other.variable;
    }
 
    std::string name;
    libMesh::FEType type;
    std::size_t size = 0;
    const libMesh::Variable * variable = nullptr;
  };
 
  struct SystemHeader
  {
    bool operator==(const SystemHeader & other) const
    {
      return name == other.name && type == other.type && variables == other.variables &&
             vectors == other.vectors;
    }
 
    std::string name;
    std::string type;
    std::map<std::string, RestartableEquationSystems::VariableHeader> variables;
    std::map<std::string, RestartableEquationSystems::VectorHeader> vectors;
    static const std::string system_solution_name;
  };
 
  struct EquationSystemsHeader
  {
    bool operator==(const EquationSystemsHeader & other) const { return systems == other.systems; }
 
    std::map<std::string, RestartableEquationSystems::SystemHeader> systems;
    std::size_t data_size = 0;
  };
 
  void store(std::ostream & stream) const;
  void load(std::istream & stream);
 
  libMesh::EquationSystems & es() { return _es; }
  const libMesh::EquationSystems & es() const { return _es; }
 
  void setLoadAllVectors(const bool load_all_vectors) { _load_all_vectors = load_all_vectors; }
 
  bool isVariableRestored(const std::string & system_name,
                          const std::string & vector_name,
                          const std::string & variable_name) const;
 
  const std::set<std::tuple<std::string, std::string, std::string>> & getLoadedVariables() const
  {
    return _loaded_variables;
  }
 
private:
  EquationSystemsHeader
  buildHeader(const std::vector<const libMesh::DofObject *> & ordered_objects) const;
 
  std::vector<const libMesh::DofObject *> orderDofObjects() const;
 
  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);
 
  libMesh::EquationSystems _es;
 
  bool _load_all_vectors;
  std::size_t _loaded_stream_data_begin;
  std::vector<const libMesh::DofObject *> _loaded_ordered_objects;
  EquationSystemsHeader _loaded_header;
 
  std::set<std::tuple<std::string, std::string, std::string>> _loaded_variables;
};
 
void dataStore(std::ostream & stream, RestartableEquationSystems & res, void *);
void dataLoad(std::istream & stream, RestartableEquationSystems & res, void *);
 
void dataStore(std::ostream & stream,
               RestartableEquationSystems::EquationSystemsHeader & header,
               void *);
void
dataLoad(std::istream & stream, RestartableEquationSystems::EquationSystemsHeader & header, void *);
 
void dataStore(std::ostream & stream, RestartableEquationSystems::SystemHeader & header, void *);
void dataLoad(std::istream & stream, RestartableEquationSystems::SystemHeader & header, void *);
 
void dataStore(std::ostream & stream, RestartableEquationSystems::VariableHeader & header, void *);
void dataLoad(std::istream & stream, RestartableEquationSystems::VariableHeader & header, void *);
 
void dataStore(std::ostream & stream, RestartableEquationSystems::VectorHeader & header, void *);
void dataLoad(std::istream & stream, RestartableEquationSystems::VectorHeader & header, void *);
 
void to_json(nlohmann::json & json, const RestartableEquationSystems & res);