differentiable_physics.hpp

Go to the documentation of this file.

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Smith Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include "gretl/data_store.hpp"
#include "smith/physics/base_physics.hpp"
#include "smith/differentiable_numerics/field_state.hpp"
#include "smith/differentiable_numerics/system_base.hpp"
#include "smith/differentiable_numerics/multiphysics_time_integrator.hpp"
#include <vector>
#include <map>
 
namespace smith {
 
class Mesh;
class WeakForm;
class StateAdvancer;
class TimestepEstimator;
class Reaction;
 
class DifferentiablePhysics : public BasePhysics {
 public:
  DifferentiablePhysics(std::shared_ptr<Mesh> mesh, std::shared_ptr<gretl::DataStore> graph,
                        const FieldState& shape_disp, const std::vector<FieldState>& states,
                        const std::vector<FieldState>& params, std::shared_ptr<StateAdvancer> advancer,
                        std::string physics_name, const std::vector<ReactionInfo>& reaction_infos = {});
  ~DifferentiablePhysics() {}
 
  void resetStates(int cycle = 0, double time = 0.0) override;
 
  virtual void resetAdjointStates() override;
 
  void completeSetup() override;
 
  std::vector<std::string> stateNames() const override;
 
  std::vector<std::string> parameterNames() const override;
 
  std::vector<std::string> dualNames() const override;
 
  const FiniteElementState& state(const std::string& state_name) const override;
 
  const FiniteElementDual& dual(const std::string& dual_name) const override;
 
  const FiniteElementState& shapeDisplacement() const override;
 
  const FiniteElementState& parameter(std::size_t parameter_index) const override;
 
  const FiniteElementState& parameter(const std::string& parameter_name) const override;
 
  FiniteElementState loadCheckpointedState(const std::string& state_name, int cycle) override;
 
  FiniteElementDual loadCheckpointedDual(const std::string& state_name, int cycle) override;
 
  void setState(const std::string& state_name, const FiniteElementState& s) override;
 
  void setShapeDisplacement(const FiniteElementState& shape_displacement) override;
 
  void setParameter(const size_t parameter_index, const FiniteElementState& parameter_state) override;
 
  void setAdjointLoad(std::unordered_map<std::string, const smith::FiniteElementDual&> string_to_dual) override;
 
  void setDualAdjointBcs(std::unordered_map<std::string, const smith::FiniteElementState&> string_to_bc) override;
 
  const FiniteElementState& adjoint(const std::string& adjoint_name) const override;
 
  virtual void advanceTimestep(double dt) override;
 
  void reverseAdjointTimestep() override;
 
  FiniteElementDual computeTimestepSensitivity(size_t parameter_index) override;
 
  const FiniteElementDual& computeTimestepShapeSensitivity() override;
 
  const std::unordered_map<std::string, const smith::FiniteElementDual&> computeInitialConditionSensitivity()
      const override;
 
  std::vector<FieldState> getInitialFieldStates() const { return initial_field_states_; }
 
  FieldState getInitialFieldState(const std::string& state_name) const;
 
  std::vector<FieldState> getFieldStates() const { return field_states_; }
 
  FieldState getFieldState(const std::string& state_name) const;
 
  std::vector<FieldState> getFieldParams() const { return field_params_; }
 
  FieldState getFieldParam(const std::string& param_name) const;
 
  std::vector<FieldState> getFieldStatesAndParamStates() const;
 
  FieldState getShapeDispFieldState() const;
 
  std::vector<ReactionState> getReactionStates() const { return reaction_states_; }
 
  std::shared_ptr<StateAdvancer> getStateAdvancer() const { return advancer_; }
 
 private:
  void initializeReactionStates();
 
  std::shared_ptr<gretl::DataStore> checkpointer_;  
  std::shared_ptr<StateAdvancer> advancer_;  
 
  std::vector<FieldState> initial_field_states_;  
  std::vector<FieldState> field_states_;          
  std::vector<FieldState> field_params_;  
  std::unique_ptr<FieldState>
      field_shape_displacement_;  
 
  std::map<std::string, size_t> state_name_to_field_index_;  
  std::map<std::string, size_t> param_name_to_field_index_;  
  std::vector<std::string> state_names_;                     
  std::vector<std::string> param_names_;                     
 
  std::vector<ReactionInfo> reaction_infos_;                       
  mutable std::vector<ReactionState> reaction_states_;             
  std::map<std::string, size_t> reaction_name_to_reaction_index_;  
  std::vector<std::string> reaction_names_;                        
 
  std::vector<gretl::Int> milestones_;  
 
  double time_prev_ =
      0.0;  
  double dt_prev_ =
      0.0;  
  int cycle_prev_ =
      0;  
};
 
template <typename SystemType>
std::unique_ptr<DifferentiablePhysics> makeDifferentiablePhysics(std::shared_ptr<SystemType> system,
                                                                 std::shared_ptr<StateAdvancer> advancer,
                                                                 const std::string& physics_name)
{
  return std::make_unique<DifferentiablePhysics>(
      system->field_store->getMesh(), system->field_store->graph(), system->field_store->getShapeDisp(),
      system->field_store->getStateFields(), system->field_store->getParameterFields(), std::move(advancer),
      physics_name, system->field_store->getReactionInfos());
}
 
template <typename SystemType>
std::unique_ptr<DifferentiablePhysics> makeDifferentiablePhysics(std::shared_ptr<SystemType> system,
                                                                 const std::string& physics_name)
{
  return makeDifferentiablePhysics(system, makeAdvancer(system), physics_name);
}
 
}  // namespace smith