Line data    Source code

       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : #ifndef LIBMESH_SINGLE_PREDICATES_H
      19             : #define LIBMESH_SINGLE_PREDICATES_H
      20             : 
      21             : // Local includes
      22             : #include "libmesh/libmesh_common.h"
      23             : #include "libmesh/id_types.h"
      24             : 
      25             : // C++ includes
      26             : #include <cstddef>
      27             : #include <vector>
      28             : #include <set>
      29             : #include <memory>
      30             : 
      31             : namespace libMesh
      32             : {
      33             : 
      34             : // Forward declarations
      35             : class BoundaryInfo;
      36             : class DofMap;
      37             : enum ElemType : int;
      38             : 
      39             : /**
      40             :  * This file declares several predicates in the Predicates namespace.  They
      41             :  * are called "single predicates" since the purpose of each one is to act
      42             :  * as a single functor which returns true or false depending on the result
      43             :  * of the operator() function.  The single predicates are used together
      44             :  * as building blocks to create the "multi predicates" which can be found
      45             :  * in the multi_predicates.h header file.
      46             :  *
      47             :  * \author John W. Peterson
      48             :  * \date 2004
      49             :  */
      50             : namespace Predicates
      51             : {
      52             : // Forward declaration
      53             : template <typename T> struct abstract_multi_predicate;
      54             : 
      55             : // abstract single predicate.  Derived classes must implement the clone()
      56             : // function.  Be careful using it since it allocates memory!  The clone()
      57             : // function is necessary since the predicate class has pure virtual
      58             : // functions.
      59             : template <typename T>
      60   469975153 : struct predicate
      61             : {
      62    17571424 :   virtual ~predicate() = default;
      63             :   virtual bool operator()(const T & it) const = 0;
      64             : 
      65             : protected:
      66             :   friend struct abstract_multi_predicate<T>;
      67             :   virtual std::unique_ptr<predicate> clone() const = 0;
      68             : };
      69             : 
      70             : 
      71             : /**
      72             :  * \returns \p true if the underlying pointer is nullptr.
      73             :  */
      74             : template <typename T>
      75           0 : struct is_null : predicate<T>
      76             : {
      77    11952033 :   virtual ~is_null() = default;
      78  6349870075 :   virtual bool operator()(const T & it) const override { return *it == nullptr; }
      79             : 
      80             : protected:
      81           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<is_null<T>>(*this); }
      82             : };
      83             : 
      84             : /**
      85             :  * \returns \p true if the pointer is not nullptr.
      86             :  */
      87             : template <typename T>
      88   332726129 : struct not_null : is_null<T>
      89             : {
      90  6546856834 :   virtual bool operator()(const T & it) const override { return !is_null<T>::operator()(it); }
      91             : 
      92             : protected:
      93   267657492 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_null<T>>(*this); }
      94             : };
      95             : 
      96             : 
      97             : /**
      98             :  * \returns \p true if the pointer is active.
      99             :  */
     100             : template <typename T>
     101    95111489 : struct active : predicate<T>
     102             : {
     103   100774158 :   virtual ~active() = default;
     104  1973427022 :   virtual bool operator()(const T & it) const override { return (*it)->active(); }
     105             : 
     106             : protected:
     107    75642585 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<active<T>>(*this); }
     108             : };
     109             : 
     110             : /**
     111             :  * \returns \p true when the pointer is inactive.
     112             :  */
     113             : template <typename T>
     114           0 : struct not_active : active<T>
     115             : {
     116           0 :   virtual bool operator()(const T & it) const override { return !active<T>::operator()(it); }
     117             : 
     118             : protected:
     119           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_active<T>>(*this); }
     120             : };
     121             : 
     122             : 
     123             : /**
     124             :  * \returns \p true if the pointer is an ancestor.
     125             :  */
     126             : template <typename T>
     127     1233520 : struct ancestor : predicate<T>
     128             : {
     129     1305320 :   virtual ~ancestor() = default;
     130    29409540 :   virtual bool operator()(const T & it) const override { return (*it)->ancestor(); }
     131             : 
     132             : protected:
     133     1020752 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<ancestor<T>>(*this); }
     134             : };
     135             : 
     136             : /**
     137             :  * \returns \p true when the pointer is not an ancestor.
     138             :  */
     139             : template <typename T>
     140           0 : struct not_ancestor : ancestor<T>
     141             : {
     142           0 :   virtual bool operator()(const T & it) const override { return !ancestor<T>::operator()(it); }
     143             : 
     144             : protected:
     145           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_ancestor<T>>(*this); }
     146             : };
     147             : 
     148             : 
     149             : /**
     150             :  * \returns \p true if the pointer is subactive.
     151             :  */
     152             : template <typename T>
     153           0 : struct subactive : predicate<T>
     154             : {
     155           0 :   virtual ~subactive() = default;
     156           0 :   virtual bool operator()(const T & it) const override { return (*it)->subactive(); }
     157             : 
     158             : protected:
     159           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<subactive<T>>(*this); }
     160             : };
     161             : 
     162             : /**
     163             :  * \returns \p true when the pointer is not subactive.
     164             :  */
     165             : template <typename T>
     166           0 : struct not_subactive : subactive<T>
     167             : {
     168           0 :   virtual bool operator()(const T & it) const override { return !subactive<T>::operator()(it); }
     169             : 
     170             : protected:
     171           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_subactive<T>>(*this); }
     172             : };
     173             : 
     174             : 
     175             : 
     176             : /**
     177             :  * \returns \p true if the pointer's processor id matches a given processor id.
     178             :  */
     179             : template <typename T>
     180   123533304 : struct pid : predicate<T>
     181             : {
     182    43870123 :   pid(processor_id_type p) : _pid(p) {}
     183   171361519 :   virtual ~pid() = default;
     184             : 
     185             :   // op()
     186  2717197740 :   virtual bool operator()(const T & it) const override { return (*it)->processor_id() == _pid; }
     187             : 
     188             : protected:
     189   124365008 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<pid<T>>(*this); }
     190             :   const processor_id_type _pid;
     191             : };
     192             : 
     193             : 
     194             : 
     195             : /**
     196             :  * \returns \p has_boundary_id(node, id).
     197             :  */
     198             : template <typename T>
     199           0 : struct bid : predicate<T>
     200             : {
     201           0 :   bid(boundary_id_type b_id,
     202             :       const BoundaryInfo & bndry_info) :
     203           0 :     _bid(b_id),
     204           0 :     _bndry_info(bndry_info)
     205           0 :   {}
     206           0 :   virtual ~bid() = default;
     207             : 
     208             :   // op()
     209             :   virtual bool operator()(const T & it) const override;
     210             : 
     211             : protected:
     212           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<bid<T>>(*this); }
     213             :   const boundary_id_type _bid;
     214             :   const BoundaryInfo & _bndry_info;
     215             : };
     216             : 
     217             : 
     218             : 
     219             : /**
     220             :  * \returns \p true if n_boundary_ids(node) > 0.
     221             :  */
     222             : template <typename T>
     223           0 : struct bnd : predicate<T>
     224             : {
     225           0 :   bnd(const BoundaryInfo & bndry_info) :
     226           0 :     _bndry_info(bndry_info)
     227           0 :   {}
     228           0 :   virtual ~bnd() = default;
     229             : 
     230             :   // op()
     231             :   virtual bool operator()(const T & it) const override;
     232             : 
     233             : protected:
     234           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<bnd<T>>(*this); }
     235             :   const BoundaryInfo & _bndry_info;
     236             : };
     237             : 
     238             : 
     239             : 
     240             : /**
     241             :  * \returns \p true if the element pointed to is semilocal to (has nodes
     242             :  * shared with an element of) a given processor id.
     243             :  */
     244             : template <typename T>
     245           0 : struct semilocal_pid : predicate<T>
     246             : {
     247           0 :   semilocal_pid(processor_id_type p) : _pid(p) {}
     248           0 :   virtual ~semilocal_pid() = default;
     249             : 
     250             :   // op()
     251           0 :   virtual bool operator()(const T & it) const override { return (*it)->is_semilocal(_pid); }
     252             : 
     253             : protected:
     254           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<semilocal_pid<T>>(*this); }
     255             :   const processor_id_type _pid;
     256             : };
     257             : 
     258             : 
     259             : 
     260             : /**
     261             :  * \returns \p true if the element pointed to is face-local to (is on
     262             :  * or has a neighbor on the partition of) a given processor id.
     263             :  */
     264             : template <typename T>
     265           0 : struct facelocal_pid : predicate<T>
     266             : {
     267           0 :   facelocal_pid(processor_id_type p) : _pid(p) {}
     268           0 :   virtual ~facelocal_pid() = default;
     269             : 
     270             :   // op()
     271           0 :   virtual bool operator()(const T & it) const override
     272             :   {
     273           0 :     if ((*it)->processor_id() == _pid)
     274           0 :       return true;
     275           0 :     for (auto n : (*it)->neighbor_ptr_range())
     276           0 :       if (n && n->processor_id() == _pid)
     277           0 :         return true;
     278           0 :     return false;
     279             :   }
     280             : 
     281             : protected:
     282           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<facelocal_pid<T>>(*this); }
     283             :   const processor_id_type _pid;
     284             : };
     285             : 
     286             : 
     287             : 
     288             : /**
     289             :  * \returns \p true if the pointer's processor id does \e not match p.
     290             :  */
     291             : template <typename T>
     292     1174620 : struct not_pid : pid<T>
     293             : {
     294      285588 :   not_pid(processor_id_type p) : pid<T>(p) {}
     295             : 
     296    29167480 :   virtual bool operator()(const T & it) const override { return !pid<T>::operator()(it); }
     297             : 
     298             : protected:
     299     1193036 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_pid<T>>(*this); }
     300             : };
     301             : 
     302             : 
     303             : /**
     304             :  * \returns \p true if the pointer's type matches the given type.  Of
     305             :  * course, this one can only be instantiated for objects which return
     306             :  * Elem pointers when dereferenced.
     307             :  */
     308             : template <typename T>
     309           0 : struct elem_type : predicate<T>
     310             : {
     311           0 :   elem_type (ElemType t) : _elem_type(t) {}
     312           0 :   virtual ~elem_type() = default;
     313             : 
     314           0 :   virtual bool operator()(const T & it) const override { return (*it)->type() == _elem_type; }
     315             : 
     316             : protected:
     317           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<elem_type<T>>(*this); }
     318             :   const ElemType _elem_type;
     319             : };
     320             : 
     321             : 
     322             : 
     323             : #ifdef LIBMESH_ENABLE_AMR
     324             : /**
     325             :  * \returns \p true if the pointer's refinement flag matches the given
     326             :  * rflag.  Of course, this one can only be instantiated for objects
     327             :  * which return Elem pointers when dereferenced.
     328             :  */
     329             : template <typename T>
     330        9312 : struct flagged : predicate<T>
     331             : {
     332        2328 :   flagged (unsigned char rflag) : _rflag(rflag) {}
     333       11680 :   virtual ~flagged() = default;
     334             : 
     335      212872 :   virtual bool operator()(const T & it) const override { return (*it)->refinement_flag() == _rflag; }
     336             : 
     337             : protected:
     338        9312 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<flagged<T>>(*this); }
     339             :   const unsigned char _rflag;
     340             : };
     341             : #endif // LIBMESH_ENABLE_AMR
     342             : 
     343             : 
     344             : 
     345             : 
     346             : 
     347             : 
     348             : /**
     349             :  * \returns \p true if the pointer's level matches the given level.
     350             :  */
     351             : template <typename T>
     352    13833236 : struct level : predicate<T>
     353             : {
     354     3567748 :   level (unsigned int l) : _level(l) {}
     355    17807336 :   virtual ~level() = default;
     356             : 
     357   628408476 :   virtual bool operator()(const T & it) const override { return (*it)->level() == _level; }
     358             : 
     359             : protected:
     360    13878292 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<level<T>>(*this); }
     361             :   const unsigned int _level;
     362             : };
     363             : 
     364             : 
     365             : 
     366             : /**
     367             :  * \returns \p true if the pointers level _does not_ match the given
     368             :  * level.
     369             :  */
     370             : template <typename T>
     371           0 : struct not_level : level<T>
     372             : {
     373           0 :   not_level(unsigned int l) : level<T>(l) {}
     374             : 
     375           0 :   virtual bool operator()(const T & it) const override { return !level<T>::operator()(it); }
     376             : 
     377             : protected:
     378           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<not_level<T>>(*this); }
     379             : };
     380             : 
     381             : 
     382             : 
     383             : 
     384             : /**
     385             :  * \returns \p true if the pointer has any \p nullptr neighbors.
     386             :  */
     387             : template <typename T>
     388             : struct null_neighbor : predicate<T>
     389             : {
     390             :   virtual ~null_neighbor() = default;
     391             :   virtual bool operator()(const T & it) const override
     392             :   {
     393             :     return (*it)->on_boundary();
     394             :   }
     395             : 
     396             : protected:
     397             :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<null_neighbor<T>>(*this); }
     398             : };
     399             : 
     400             : 
     401             : 
     402             : /**
     403             :  * \returns \p side_on_boundary().
     404             :  *
     405             :  * This predicate simply forwards the work of determining whether a
     406             :  * particular side is on the boundary to the iterator itself, which
     407             :  * has more information.
     408             :  */
     409             : template <typename T>
     410           0 : struct boundary_side : predicate<T>
     411             : {
     412           0 :   virtual ~boundary_side() = default;
     413           0 :   virtual bool operator()(const T & it) const override
     414             :   {
     415           0 :     return it.side_on_boundary();
     416             :   }
     417             : 
     418             : protected:
     419           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<boundary_side<T>>(*this); }
     420             : };
     421             : 
     422             : /**
     423             :  * \returns \p true if the pointer's \p subdomain_id() matches a given
     424             :  * id.
     425             :  */
     426             : template <typename T>
     427       24798 : struct subdomain : predicate<T>
     428             : {
     429        7426 :   subdomain(subdomain_id_type sid) : _subdomain(sid) {}
     430       34080 :   virtual ~subdomain() = default;
     431             : 
     432             :   // op()
     433       47981 :   virtual bool operator()(const T & it) const override { return (*it)->subdomain_id() == _subdomain; }
     434             : 
     435             : protected:
     436       24798 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<subdomain<T>>(*this); }
     437             :   const subdomain_id_type _subdomain;
     438             : };
     439             : 
     440             : 
     441             : /**
     442             :  * \returns \p true if the pointer's \p subdomain_id() is in the
     443             :  * provided \p std::set<subdomain_id_type>.
     444             :  */
     445             : template <typename T>
     446           0 : struct subdomain_set : predicate<T>
     447             : {
     448           0 :   subdomain_set(std::set<subdomain_id_type> sset) : _subdomain_set(sset) {}
     449           0 :   virtual ~subdomain_set() = default;
     450             : 
     451             :   // op()
     452           0 :   virtual bool operator()(const T & it) const override { return _subdomain_set.count((*it)->subdomain_id()); }
     453             : 
     454             : protected:
     455           0 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<subdomain_set<T>>(*this); }
     456             :   const std::set<subdomain_id_type> _subdomain_set;
     457             : };
     458             : 
     459             : 
     460             : /**
     461             :  * \returns \p true if the pointer (which must be a non-null dof object) has
     462             :  * degrees of freedom which can be evaluated for the specified DofMap
     463             :  * and variable.
     464             :  */
     465             : template <typename T>
     466        1704 : struct evaluable : predicate<T>
     467             : {
     468         852 :   evaluable(const DofMap & dof_map,
     469             :             unsigned int var_num) :
     470         852 :     _dof_map(dof_map), _var_num(var_num) {}
     471        2628 :   virtual ~evaluable() = default;
     472             : 
     473             :   // op()
     474             :   virtual bool operator()(const T & it) const override;
     475             : 
     476             : protected:
     477        1704 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<evaluable<T>>(*this); }
     478             :   const DofMap & _dof_map;
     479             :   unsigned int _var_num;
     480             : };
     481             : 
     482             : /**
     483             :  * \returns \p true if the pointer (which must be a non-null dof object) has
     484             :  * degrees of freedom which can be evaluated for all variables in all the provided
     485             :  * \p DofMaps
     486             :  */
     487             : template <typename T>
     488         276 : struct multi_evaluable : predicate<T>
     489             : {
     490         142 :   multi_evaluable(std::vector<const DofMap *> dof_maps) :
     491         142 :       _dof_maps(dof_maps) {}
     492         450 :   virtual ~multi_evaluable() = default;
     493             : 
     494             :   // op()
     495             :   virtual bool operator()(const T & it) const override;
     496             : 
     497             : protected:
     498         284 :   virtual std::unique_ptr<predicate<T>> clone() const override { return std::make_unique<multi_evaluable<T>>(*this); }
     499             :   std::vector<const DofMap *> _dof_maps;
     500             : };
     501             : 
     502             : 
     503             : } // namespace Predicates
     504             : 
     505             : 
     506             : } // namespace libMesh
     507             : 
     508             : #endif // LIBMESH_SINGLE_PREDICATES_H