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

// MOOSE includes
#include "Transfer.h"
#include "MultiMooseEnum.h"
#include "MultiApp.h"
#include "MooseAppCoordTransform.h"

#include "libmesh/bounding_box.h"

class MooseMesh;

class MultiAppTransfer : public Transfer
{
public:
  static InputParameters validParams();

  MultiAppTransfer(const InputParameters & parameters);

  void variableIntegrityCheck(const AuxVariableName & var_name, bool is_from_multiapp) const;

  void initialSetup() override;

  const std::shared_ptr<MultiApp> getMultiApp() const
  {
    if (_from_multi_app && _to_multi_app && _from_multi_app != _to_multi_app)
      mooseError("Unclear which app you want to retrieve from Transfer ", name());
    else if (_from_multi_app)
      return _from_multi_app;
    else if (_to_multi_app)
      return _to_multi_app;
    else if (_multi_app)
      return _multi_app;
    else
      mooseError("Should not get here, there should be a multiapp");
  }

  const std::shared_ptr<MultiApp> getFromMultiApp() const
  {
    if (!_from_multi_app)
      mooseError(
          "A from_multiapp was requested but is unavailable. Check the from_multi_app parameter");
    else
      return _from_multi_app;
  }

  const std::shared_ptr<MultiApp> getToMultiApp() const
  {
    if (!_to_multi_app)
      mooseError(
          "A to_multiapp was requested but is unavailable. Check the to_multi_app parameter");
    else
      return _to_multi_app;
  }

  std::string getFromName() const
  {
    if (_from_multi_app)
      return _from_multi_app->name();
    else
      return "Parent";
  }

  std::string getToName() const
  {
    if (_to_multi_app)
      return _to_multi_app->name();
    else
      return "Parent";
  }

  bool hasFromMultiApp() const { return !(!_from_multi_app); }

  bool hasToMultiApp() const { return !(!_to_multi_app); }

  virtual void getAppInfo();

  static void addSkipCoordCollapsingParam(InputParameters & params);

protected:
  static void addUserObjectExecutionCheckParam(InputParameters & params);

  static void addBBoxFactorParam(InputParameters & params);

  static void transformBoundingBox(libMesh::BoundingBox & box,
                                   const MultiAppCoordTransform & transform);

  std::shared_ptr<MultiApp> _multi_app;

  std::vector<FEProblemBase *> _to_problems;
  std::vector<FEProblemBase *> _from_problems;
  std::vector<libMesh::EquationSystems *> _to_es;
  std::vector<libMesh::EquationSystems *> _from_es;
  std::vector<MooseMesh *> _to_meshes;
  std::vector<MooseMesh *> _from_meshes;
  std::vector<Point> _to_positions;
  std::vector<Point> _from_positions;
  std::vector<std::unique_ptr<MultiAppCoordTransform>> _to_transforms;
  std::vector<std::unique_ptr<MultiAppCoordTransform>> _from_transforms;

  const bool _skip_coordinate_collapsing;

  bool _displaced_source_mesh;
  bool _displaced_target_mesh;

  Real _bbox_factor;


  std::vector<libMesh::BoundingBox> getFromBoundingBoxes();
  std::vector<libMesh::BoundingBox> getFromBoundingBoxes(BoundaryID boundary_id);

  std::vector<unsigned int> getFromsPerProc();

  libMesh::NumericVector<Real> & getTransferVector(unsigned int i_local, std::string var_name);

  std::vector<unsigned int> _to_local2global_map;
  std::vector<unsigned int> _from_local2global_map;

  unsigned int getGlobalSourceAppIndex(unsigned int i_from) const;
  unsigned int getGlobalTargetAppIndex(unsigned int i_to) const;
  unsigned int getLocalSourceAppIndex(unsigned int i_from) const;

  virtual void checkSiblingsTransferSupported() const
  {
    mooseError("Siblings transfer not supported. You cannot transfer both from a multiapp to "
               "another multiapp");
  }

  void checkParentAppUserObjectExecuteOn(const std::string & object_name) const;

  void errorIfObjectExecutesOnTransferInSourceApp(const std::string & object_name) const;

  Point getPointInTargetAppFrame(const Point & p,
                                 unsigned int local_i_to,
                                 const std::string & phase) const;

  Point getPointInSourceAppFrame(const Point & p,
                                 unsigned int local_i_from,
                                 const std::string & phase) const;

  void checkMultiAppExecuteOn();

  void checkVariable(const FEProblemBase & fe_problem,
                     const VariableName & var_name,
                     const std::string & param_name = "") const;

  void extendBoundingBoxes(const Real factor, std::vector<libMesh::BoundingBox> & bboxes) const;

private:
  virtual bool usesMooseAppCoordTransform() const { return false; }

  Point mapBackWithoutCollapsing(MultiAppCoordTransform & transform,
                                 const Point & p,
                                 const std::string & phase) const;

  std::shared_ptr<MultiApp> _from_multi_app;
  std::shared_ptr<MultiApp> _to_multi_app;

  void getFromMultiAppInfo();
  void getToMultiAppInfo();

  std::unique_ptr<MooseAppCoordTransform> _from_moose_app_transform;

  std::unique_ptr<MooseAppCoordTransform> _to_moose_app_transform;
};