state_manager.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024, Lawrence Livermore National Security, LLC and
// other Serac Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <optional>
#include <unordered_map>
 
#include "mfem.hpp"
#include "axom/sidre/core/MFEMSidreDataCollection.hpp"
 
#include "serac/infrastructure/logger.hpp"
#include "serac/physics/state/finite_element_state.hpp"
#include "serac/physics/state/finite_element_dual.hpp"
#include "serac/numerics/functional/quadrature_data.hpp"
 
namespace serac {
 
constexpr int SHAPE_ORDER = 1;
 
constexpr H1<SHAPE_ORDER, 2> SHAPE_DIM_2;
 
constexpr H1<SHAPE_ORDER, 3> SHAPE_DIM_3;
 
class StateManager {
public:
  static void initialize(axom::sidre::DataStore& ds, const std::string& output_directory);
 
  template <typename FunctionSpace>
  static FiniteElementState newState(FunctionSpace space, const std::string& state_name, const std::string& mesh_tag)
  {
    SLIC_ERROR_ROOT_IF(!ds_, "Serac's data store was not initialized - call StateManager::initialize first");
    SLIC_ERROR_ROOT_IF(datacolls_.find(mesh_tag) == datacolls_.end(),
                       axom::fmt::format("Mesh tag '{}' not found in the data store", mesh_tag));
    SLIC_ERROR_ROOT_IF(named_states_.find(state_name) != named_states_.end(),
                       axom::fmt::format("StateManager already contains a state named '{}'", state_name));
 
    auto state = FiniteElementState(mesh(mesh_tag), space, state_name);
 
    storeState(state);
    return state;
  }
 
  static FiniteElementState newState(const mfem::ParFiniteElementSpace& space, const std::string& state_name);
 
  static void storeState(FiniteElementState& state);
 
  template <typename FunctionSpace>
  static FiniteElementDual newDual(FunctionSpace space, const std::string& dual_name, const std::string& mesh_tag)
  {
    SLIC_ERROR_ROOT_IF(!ds_, "Serac's data store was not initialized - call StateManager::initialize first");
    SLIC_ERROR_ROOT_IF(datacolls_.find(mesh_tag) == datacolls_.end(),
                       axom::fmt::format("Mesh tag '{}' not found in the data store", mesh_tag));
    SLIC_ERROR_ROOT_IF(named_states_.find(dual_name) != named_duals_.end(),
                       axom::fmt::format("StateManager already contains a dual named '{}'", dual_name));
 
    auto dual = FiniteElementDual(mesh(mesh_tag), space, dual_name);
 
    storeDual(dual);
    return dual;
  }
  static FiniteElementDual newDual(const mfem::ParFiniteElementSpace& space, const std::string& dual_name);
 
  static void storeDual(FiniteElementDual& dual);
 
  static void updateState(const FiniteElementState& state)
  {
    SLIC_ERROR_ROOT_IF(named_states_.find(state.name()) == named_states_.end(),
                       axom::fmt::format("State manager does not contain state named '{}'", state.name()));
 
    state.fillGridFunction(*named_states_[state.name()]);
  }
 
  static void updateDual(const FiniteElementDual& dual)
  {
    SLIC_ERROR_ROOT_IF(named_duals_.find(dual.name()) == named_duals_.end(),
                       axom::fmt::format("State manager does not contain dual named '{}'", dual.name()));
 
    dual.space().GetRestrictionMatrix()->MultTranspose(dual, *named_duals_[dual.name()]);
  }
 
  static void save(const double t, const int cycle, const std::string& mesh_tag);
 
  static double load(const int cycle_to_load, const std::string& mesh_tag)
  {
    // FIXME: Assumes that if one DataCollection is going to be reloaded all DataCollections will be
    is_restart_ = true;
    return newDataCollection(mesh_tag, cycle_to_load);
  }
 
  static void reset()
  {
    named_states_.clear();
    named_duals_.clear();
    shape_displacements_.clear();
    datacolls_.clear();
    output_dir_.clear();
    is_restart_ = false;
    ds_         = nullptr;
  };
 
  static mfem::ParMesh& setMesh(std::unique_ptr<mfem::ParMesh> pmesh, const std::string& mesh_tag);
 
  static mfem::ParMesh& mesh(const std::string& mesh_tag);
 
  static FiniteElementState& shapeDisplacement(const std::string& mesh_tag);
 
  static void loadCheckpointedStates(int                                                     cycle_to_load,
                                     std::vector<std::reference_wrapper<FiniteElementState>> states_to_load);
 
  static FiniteElementDual& shapeDisplacementSensitivity(const std::string& mesh_tag);
 
  static std::string collectionID(const mfem::ParMesh* pmesh);
 
  static bool isRestart() { return is_restart_; }
 
  static int cycle(std::string mesh_tag);
 
  static double time(std::string mesh_tag);
 
private:
  static double newDataCollection(const std::string& name, const std::optional<int> cycle_to_load = {});
 
  static void constructShapeFields(const std::string& mesh_tag);
 
  static std::unordered_map<std::string, axom::sidre::MFEMSidreDataCollection> datacolls_;
 
  static std::unordered_map<std::string, std::unique_ptr<FiniteElementState>> shape_displacements_;
 
  static bool is_restart_;
 
  static axom::sidre::DataStore* ds_;
  static std::string output_dir_;
 
  static std::unordered_map<std::string, mfem::ParGridFunction*> named_states_;
  static std::unordered_map<std::string, mfem::ParGridFunction*> named_duals_;
};
 
}  // namespace serac