BoundaryRestrictable.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
 
#ifdef MOOSE_KOKKOS_ENABLED
#include "KokkosTypes.h"
#endif
 
// MOOSE includes
#include "InputParameters.h"
#include "MaterialData.h"
 
class MooseMesh;
 
class BoundaryRestrictable
{
public:
  enum TEST_TYPE
  {
    ALL,
    ANY
  };
 
  BoundaryRestrictable(const MooseObject * moose_object, bool nodal);
 
  static InputParameters validParams();
 
  BoundaryRestrictable(const MooseObject * moose_object,
                       const std::set<SubdomainID> & block_ids,
                       bool nodal);
 
#ifdef MOOSE_KOKKOS_ENABLED
  BoundaryRestrictable(const BoundaryRestrictable & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  static bool restricted(const std::set<BoundaryID> & ids);
 
  virtual ~BoundaryRestrictable();
 
  const virtual std::set<BoundaryID> & boundaryIDs() const;
 
  const std::vector<BoundaryName> & boundaryNames() const;
 
  unsigned int numBoundaryIDs() const;
 
  bool hasBoundary(const BoundaryName & name) const;
 
  bool hasBoundary(const std::vector<BoundaryName> & names) const;
 
  bool hasBoundary(const BoundaryID & id) const;
 
  bool hasBoundary(const std::vector<BoundaryID> & ids, TEST_TYPE type = ALL) const;
 
  bool hasBoundary(const std::set<BoundaryID> & ids, TEST_TYPE type = ALL) const;
 
  bool isBoundarySubset(const std::set<BoundaryID> & ids) const;
 
  /*
   * Test if the class boundary ids are a subset of the supplied objects
   * @param ids A std::set of Boundary IDs to check
   * @return True if all of the boundary ids for this class are found within the given ids (opposite
   * of hasBoundary)
   * \see hasBoundary
   */
  bool isBoundarySubset(const std::vector<BoundaryID> & ids) const;
 
  template <typename T, bool is_ad = false>
  bool hasBoundaryMaterialProperty(const std::string & prop_name) const;
 
  virtual bool boundaryRestricted() const;
 
  const std::set<BoundaryID> & meshBoundaryIDs() const;
 
  virtual bool checkVariableBoundaryIntegrity() const { return true; }
 
private:
  FEProblemBase * _bnd_feproblem;
 
  MooseMesh * _bnd_mesh;
 
  std::set<BoundaryID> _bnd_ids;
 
  std::vector<BoundaryID> _vec_ids;
 
  std::vector<BoundaryName> _boundary_names;
 
  const bool _bnd_dual_restrictable;
 
  const std::set<SubdomainID> _empty_block_ids;
 
  const std::set<SubdomainID> & _block_ids;
 
  THREAD_ID _bnd_tid;
 
  const MaterialData & _bnd_material_data;
 
  bool _bnd_nodal;
 
  const MooseObject & _moose_object;
 
  void initializeBoundaryRestrictable();
 
#ifdef MOOSE_KOKKOS_ENABLED
  void initializeKokkosBoundaryRestrictable();
#endif
 
protected:
  bool hasBoundaryMaterialPropertyHelper(const std::string & prop_name) const;
 
#ifdef MOOSE_KOKKOS_SCOPE
  KOKKOS_FUNCTION dof_id_type numKokkosBoundaryNodes() const { return _kokkos_node_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBoundarySides() const
  {
    return _kokkos_element_side_ids.size();
  }
  KOKKOS_FUNCTION ContiguousNodeID kokkosBoundaryNodeID(Moose::Kokkos::ThreadID tid) const
  {
    return _kokkos_node_ids[tid];
  }
  KOKKOS_FUNCTION auto kokkosBoundaryElementSideID(Moose::Kokkos::ThreadID tid) const
  {
    return _kokkos_element_side_ids[tid];
  }
#endif
 
#ifdef MOOSE_KOKKOS_ENABLED
private:
  Moose::Kokkos::Array<ContiguousNodeID> _kokkos_node_ids;
  Moose::Kokkos::Array<Moose::Kokkos::Pair<ContiguousElementID, unsigned int>>
      _kokkos_element_side_ids;
#endif
};
 
template <typename T, bool is_ad>
bool
BoundaryRestrictable::hasBoundaryMaterialProperty(const std::string & prop_name) const
{
  // If you get here the supplied property is defined on all boundaries, but is still subject
  // existence in the MateialData class
  return hasBoundaryMaterialPropertyHelper(prop_name) &&
         _bnd_material_data.haveGenericProperty<T, is_ad>(prop_name);
}