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;
};