functional_objective.hpp

Go to the documentation of this file.

// Copyright 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 "serac/physics/scalar_objective.hpp"
#include "serac/physics/mesh.hpp"
#include "serac/numerics/functional/shape_aware_functional.hpp"
#include "serac/physics/state/finite_element_state.hpp"
#include "serac/physics/state/finite_element_dual.hpp"
 
namespace serac {
 
template <int spatial_dim, typename parameters = Parameters<>,
          typename parameter_indices = std::make_integer_sequence<int, parameters::n>>
class FunctionalObjective;
 
template <int spatial_dim, typename... InputSpaces, int... parameter_indices>
class FunctionalObjective<spatial_dim, Parameters<InputSpaces...>, std::integer_sequence<int, parameter_indices...>>
    : public ScalarObjective {
 public:
  using SpacesT = std::vector<const mfem::ParFiniteElementSpace*>;  
 
  using ShapeDispSpace = H1<1, spatial_dim>;  
 
  FunctionalObjective(const std::string& physics_name, std::shared_ptr<Mesh> mesh, const SpacesT& input_mfem_spaces)
      : ScalarObjective(physics_name), mesh_(mesh)
  {
    std::array<const mfem::ParFiniteElementSpace*, sizeof...(InputSpaces)> mfem_spaces;
 
    SLIC_ERROR_ROOT_IF(
        sizeof...(InputSpaces) != input_mfem_spaces.size(),
        axom::fmt::format("{} parameter spaces given in the template argument but {} parameter names were supplied.",
                          sizeof...(InputSpaces), input_mfem_spaces.size()));
 
    if constexpr (sizeof...(InputSpaces) > 0) {
      for_constexpr<sizeof...(InputSpaces)>([&](auto i) { mfem_spaces[i] = input_mfem_spaces[i]; });
    }
 
    const auto& shape_disp_space = mesh_->shapeDisplacementSpace();
 
    objective_ =
        std::make_unique<ShapeAwareFunctional<ShapeDispSpace, double(InputSpaces...)>>(&shape_disp_space, mfem_spaces);
  }
 
  template <int... active_parameters, typename FuncOfTimeSpaceAndParams>
  void addBodyIntegral(DependsOn<active_parameters...>, std::string body_name,
                       const FuncOfTimeSpaceAndParams& qfunction)
  {
    objective_->AddDomainIntegral(serac::Dimension<spatial_dim>{}, serac::DependsOn<active_parameters...>{}, qfunction,
                                  mesh_->domain(body_name));
  }
 
  virtual double evaluate(double time, double dt, ConstFieldPtr shape_disp,
                          const std::vector<ConstFieldPtr>& fields) const override
  {
    dt_ = dt;
    return evaluateObjective(std::make_integer_sequence<int, sizeof...(parameter_indices)>{}, time, shape_disp, fields);
  }
 
  virtual mfem::Vector gradient(double time, double dt, ConstFieldPtr shape_disp,
                                const std::vector<ConstFieldPtr>& fields, int field_ordinal) const override
  {
    dt_ = dt;
    auto grads =
        gradientEvaluators(std::make_integer_sequence<int, sizeof...(parameter_indices)>{}, time, shape_disp, fields);
    auto g = serac::get<DERIVATIVE>(grads[static_cast<size_t>(field_ordinal)](time, shape_disp, fields));
    return *assemble(g);
  }
 
  virtual mfem::Vector mesh_coordinate_gradient(double time, double dt, ConstFieldPtr shape_disp,
                                                const std::vector<ConstFieldPtr>& fields) const override
  {
    dt_ = dt;
    auto g =
        serac::get<DERIVATIVE>((*objective_)(DifferentiateWRT<0>{}, time, *shape_disp, *fields[parameter_indices]...));
    return *assemble(g);
  }
 
 private:
  template <int... i>
  auto evaluateObjective(std::integer_sequence<int, i...>, double time, ConstFieldPtr shape_disp,
                         const std::vector<ConstFieldPtr>& fs) const
  {
    return (*objective_)(time, *shape_disp, *fs[i]...);
  };
 
  template <int... i>
  auto gradientEvaluators(std::integer_sequence<int, i...>, double time, ConstFieldPtr shape_disp,
                          const std::vector<ConstFieldPtr>& fs) const
  {
    using JacFuncType = std::function<decltype((*objective_)(DifferentiateWRT<1>{}, time, *shape_disp, *fs[i]...))(
        double, ConstFieldPtr, const std::vector<ConstFieldPtr>&)>;
    return std::array<JacFuncType, sizeof...(i)>{
        [=](double _time, ConstFieldPtr _shape_disp, const std::vector<ConstFieldPtr>& _fs) {
          return (*objective_)(DifferentiateWRT<i + 1>{}, _time, *_shape_disp, *_fs[i]...);
        }...};
  };
 
  mutable double dt_ = std::numeric_limits<double>::max();
 
  std::shared_ptr<Mesh> mesh_;
 
  std::unique_ptr<ShapeAwareFunctional<ShapeDispSpace, double(InputSpaces...)>> objective_;
};
 
}  // namespace serac