RelationshipManager.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
 
#include "MooseObject.h"
#include "InputParameters.h"
#include "MooseMesh.h"
 
#include "libmesh/ghosting_functor.h"
 
class MooseMesh;
 
class RelationshipManager : public MooseObject, public libMesh::GhostingFunctor
{
public:
  static InputParameters validParams();
 
  RelationshipManager(const InputParameters & parameters);
 
  RelationshipManager(const RelationshipManager & other);
 
  void
  init(MooseMesh & moose_mesh, const MeshBase & mesh, const libMesh::DofMap * dof_map = nullptr);
 
  bool inited() { return _inited; }
 
  virtual const std::vector<std::string> & forWhom() const { return _for_whom; }
 
  void addForWhom(const std::string & for_whom) { _for_whom.push_back(for_whom); }
 
  virtual std::string getInfo() const = 0;
 
  Moose::RelationshipManagerType getType() const { return _rm_type; }
 
  bool isType(const Moose::RelationshipManagerType & type) const
  {
    return (_rm_type & type) == type;
  }
 
  virtual bool operator==(const RelationshipManager & /*rhs*/) const
  {
    mooseError("RelationshipManager::operator>= must be overridden");
  }
 
  virtual bool operator>=(const RelationshipManager & rhs) const
  {
    mooseDeprecated(
        "Are you overriding RelationshipManager::operator==? We are transitioning to make "
        "operator>= "
        "the required override. If you are not overriding operator>= or operator==, you are about "
        "to get an error message saying that operator>= must be overridden.");
 
    return *this == rhs;
  }
 
  virtual bool baseGreaterEqual(const RelationshipManager & rhs) const;
 
  bool attachGeometricEarly() { return _attach_geometric_early; }
 
  bool useDisplacedMesh() const { return _use_displaced_mesh; }
 
  const libMesh::DofMap * dofMap() { return _dof_map; }
 
protected:
  virtual void internalInitWithMesh(const MeshBase &) { internalInit(); }
  virtual void internalInit() {}
 
  bool _inited = false;
 
  MooseMesh * _moose_mesh;
 
  const libMesh::DofMap * _dof_map = nullptr;
 
  const bool _attach_geometric_early;
 
  Moose::RelationshipManagerType _rm_type;
 
  std::vector<std::string> _for_whom;
 
  const bool _use_displaced_mesh;
 
public:
  static bool isGeometric(Moose::RelationshipManagerType input_rm);
 
  static bool isAlgebraic(Moose::RelationshipManagerType input_rm);
 
  static bool isCoupling(Moose::RelationshipManagerType input_rm);
 
  static Moose::RelationshipManagerType geo_and_alg;
 
  static Moose::RelationshipManagerType geo_alg_and_coupl;
 
  static InputParameters zeroLayerGhosting();
 
  static InputParameters oneLayerGhosting(Moose::RelationshipManagerType rm_type);
};