BlockRestrictable.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 "ParallelUniqueId.h"
#include "MaterialData.h"
#include "MooseObject.h"
 
#define usingBlockRestrictableMembers using BlockRestrictable::getBlockCoordSystem
 
class FEProblemBase;
class MooseMesh;
 
#ifdef MOOSE_KOKKOS_ENABLED
namespace Moose::Kokkos
{
class Mesh;
}
#endif
 
class MooseVariableFieldBase;
 
class BlockRestrictable
{
public:
  BlockRestrictable(const MooseObject * moose_object, bool initialize = true);
 
  static InputParameters validParams();
 
  BlockRestrictable(const MooseObject * moose_object, const std::set<BoundaryID> & boundary_ids);
 
#ifdef MOOSE_KOKKOS_ENABLED
  BlockRestrictable(const BlockRestrictable & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  virtual ~BlockRestrictable() {}
 
  const std::vector<SubdomainName> & blocks() const;
 
  unsigned int numBlocks() const;
 
  virtual const std::set<SubdomainID> & blockIDs() const;
 
  unsigned int blocksMaxDimension() const;
 
  bool hasBlocks(const SubdomainName & name) const;
 
  bool hasBlocks(const std::vector<SubdomainName> & names) const;
 
  bool hasBlocks(const std::set<SubdomainName> & names) const;
 
  bool hasBlocks(SubdomainID id) const;
 
  bool hasBlocks(const std::vector<SubdomainID> & ids) const;
 
  bool hasBlocks(const std::set<SubdomainID> & ids) const;
 
  bool isBlockSubset(const std::set<SubdomainID> & ids) const;
 
  bool isBlockSubset(const std::vector<SubdomainID> & ids) const;
 
  template <typename T, bool is_ad = false>
  bool hasBlockMaterialProperty(const std::string & prop_name);
 
  const std::set<SubdomainID> & meshBlockIDs() const;
 
  virtual bool blockRestricted() const;
 
  virtual void checkVariable(const MooseVariableFieldBase & variable) const;
 
protected:
  const MaterialData * _blk_material_data;
 
  virtual bool hasBlockMaterialPropertyHelper(const std::string & prop_name);
 
  void initializeBlockRestrictable(const MooseObject * moose_object);
 
#ifdef MOOSE_KOKKOS_ENABLED
  void initializeKokkosBlockRestrictable();
#endif
 
  Moose::CoordinateSystemType getBlockCoordSystem();
 
#ifdef MOOSE_KOKKOS_SCOPE
  KOKKOS_FUNCTION dof_id_type numKokkosBlockElements() const { return _kokkos_element_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBlockNodes() const { return _kokkos_node_ids.size(); }
  KOKKOS_FUNCTION dof_id_type numKokkosBlockSides() const
  {
    return _kokkos_element_side_ids.size();
  }
  KOKKOS_FUNCTION ContiguousElementID kokkosBlockElementID(Moose::Kokkos::ThreadID tid) const
  {
    return _kokkos_element_ids[tid];
  }
  KOKKOS_FUNCTION ContiguousElementID kokkosBlockNodeID(Moose::Kokkos::ThreadID tid) const
  {
    return _kokkos_node_ids[tid];
  }
  KOKKOS_FUNCTION auto kokkosBlockElementSideID(Moose::Kokkos::ThreadID tid) const
  {
    return _kokkos_element_side_ids[tid];
  }
#endif
 
private:
  std::set<SubdomainID> _blk_ids;
 
  std::vector<SubdomainID> _vec_ids;
 
  std::vector<SubdomainName> _blocks;
 
  const bool _blk_dual_restrictable;
 
  FEProblemBase * _blk_feproblem;
 
  const MooseMesh * _blk_mesh;
 
  const std::set<BoundaryID> _empty_boundary_ids;
 
  const std::set<BoundaryID> & _boundary_ids;
 
  THREAD_ID _blk_tid;
 
  const std::string & _blk_name;
 
  unsigned int _blk_dim;
 
  const MooseObject * _moose_object;
 
#ifdef MOOSE_KOKKOS_ENABLED
  Moose::Kokkos::Array<ContiguousElementID> _kokkos_element_ids;
  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
BlockRestrictable::hasBlockMaterialProperty(const std::string & prop_name)
{
  mooseAssert(_blk_material_data != NULL, "MaterialData pointer is not defined");
  return hasBlockMaterialPropertyHelper(prop_name) &&
         _blk_material_data->haveGenericProperty<T, is_ad>(prop_name);
}