MFEMMultiAppTransfer.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

#ifdef MOOSE_MFEM_ENABLED

#pragma once

#include "MultiAppTransfer.h"
#include "FEProblemBase.h"

class MFEMMultiAppTransfer : public MultiAppTransfer
{
public:
  static InputParameters validParams();
  MFEMMultiAppTransfer(InputParameters const & params);
  void execute() override;
  void checkSiblingsTransferSupported() const override {}

  const VariableName & getFromVarName(int i) const { return _from_var_names.at(i); }
  const VariableName & getToVarName(int i) const { return _to_var_names.at(i); }
  unsigned int numFromVar() const { return _from_var_names.size(); }
  unsigned int numToVar() const { return _to_var_names.size(); }

protected:
  virtual void transferVariables(bool is_target_local) = 0;

  void setActiveFromProblem(FEProblemBase & from_problem, const unsigned int global_app_index)
  {
    _active_from_problem = &from_problem;
    _active_from_global_app_index = global_app_index;
  }
  void setActiveToProblem(FEProblemBase & to_problem, const unsigned int global_app_index)
  {
    _active_to_problem = &to_problem;
    _active_to_global_app_index = global_app_index;
  }
  virtual FEProblemBase & getActiveFromProblem() { return *_active_from_problem; }
  virtual FEProblemBase & getActiveToProblem() { return *_active_to_problem; }
  virtual unsigned int & getActiveToProblemGlobalAppIndex() { return _active_to_global_app_index; }
  virtual unsigned int & getActiveFromProblemGlobalAppIndex()
  {
    return _active_from_global_app_index;
  }

  const MultiAppCoordTransform & getActiveFromTransform() const
  {
    return *_from_transforms[_active_from_global_app_index];
  }
  const MultiAppCoordTransform & getActiveToTransform() const
  {
    return *_to_transforms[_active_to_global_app_index];
  }
  libMesh::Point mapPointToActiveSourceFrame(const Point & point_in_target_frame) const
  {
    return getActiveFromTransform().mapBack(getActiveToTransform()(point_in_target_frame));
  }
  libMesh::EquationSystems & getlibMeshEquationSystem(FEProblemBase & problem,
                                                      bool use_displaced) const;

  void setMFEMOutOfMeshValue(mfem::real_t mfem_out_of_mesh_value)
  {
    _mfem_out_of_mesh_value = mfem_out_of_mesh_value;
  }
  mfem::real_t getMFEMOutOfMeshValue() const { return _mfem_out_of_mesh_value; }

  template <Moose::FEBackend TO_BACKEND, Moose::FEBackend FROM_BACKEND>
  void checkValidTransferProblemTypes();

private:
  const std::vector<VariableName> & _from_var_names;
  const std::vector<VariableName> & _to_var_names;
  FEProblemBase * _active_to_problem{nullptr};
  FEProblemBase * _active_from_problem{nullptr};
  unsigned int _active_to_global_app_index{0};
  unsigned int _active_from_global_app_index{0};
  mfem::real_t _mfem_out_of_mesh_value{std::numeric_limits<mfem::real_t>::infinity()};
};

template <Moose::FEBackend TO_BACKEND, Moose::FEBackend FROM_BACKEND>
inline void
MFEMMultiAppTransfer::checkValidTransferProblemTypes()
{
  // Check if source sub-apps exist, and if so, if they are of the expected type
  if (hasFromMultiApp())
  {
    for (const auto i : make_range(getFromMultiApp()->numGlobalApps()))
      if (getFromMultiApp()->hasLocalApp(i) &&
          getFromMultiApp()->appProblemBase(i).feBackend() != FROM_BACKEND)
        paramError("from_multi_app", type() + " is incompatible with the source app's backend.");
  }
  else if (getToMultiApp()->problemBase().feBackend() != FROM_BACKEND)
    mooseError(type() + " is incompatible with this (the source) app's backend.");

  // Check if destination sub-apps exist, and if so, if they are of the expected type
  if (hasToMultiApp())
  {
    for (const auto i : make_range(getToMultiApp()->numGlobalApps()))
      if (getToMultiApp()->hasLocalApp(i) &&
          getToMultiApp()->appProblemBase(i).feBackend() != TO_BACKEND)
        paramError("to_multi_app", type() + " is incompatible with the destination app's backend.");
  }
  else if (getFromMultiApp()->problemBase().feBackend() != TO_BACKEND)
    mooseError(type() + " is incompatible with this (the destination) app's backend.");
}

#endif