Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "Attributes.h"
      11             : 
      12             : #include "TaggingInterface.h"
      13             : #include "BoundaryRestrictable.h"
      14             : #include "BlockRestrictable.h"
      15             : #include "SetupInterface.h"
      16             : #include "MooseVariableInterface.h"
      17             : #include "MooseVariableFE.h"
      18             : #include "ElementUserObject.h"
      19             : #include "SideUserObject.h"
      20             : #include "InternalSideUserObject.h"
      21             : #include "InterfaceUserObject.h"
      22             : #include "NodalUserObject.h"
      23             : #include "GeneralUserObject.h"
      24             : #include "ThreadedGeneralUserObject.h"
      25             : #include "ShapeUserObject.h"
      26             : #include "ShapeSideUserObject.h"
      27             : #include "ShapeElementUserObject.h"
      28             : #include "Reporter.h"
      29             : #include "SystemBase.h"
      30             : #include "DomainUserObject.h"
      31             : #include "MortarUserObject.h"
      32             : #include "FVInterpolationMethod.h"
      33             : #include "ExecFlagRegistry.h"
      34             : 
      35             : #include <algorithm>
      36             : 
      37             : const ExecFlagType AttribExecOns::EXEC_ALL = registerExecFlag("ALL");
      38             : 
      39             : std::ostream &
      40           0 : operator<<(std::ostream & os, Interfaces & iface)
      41             : {
      42           0 :   os << "Interfaces(";
      43           0 :   if (static_cast<bool>(iface & Interfaces::UserObject))
      44           0 :     os << "|UserObject";
      45           0 :   if (static_cast<bool>(iface & Interfaces::ElementUserObject))
      46           0 :     os << "|ElementUserObject";
      47           0 :   if (static_cast<bool>(iface & Interfaces::SideUserObject))
      48           0 :     os << "|SideUserObject";
      49           0 :   if (static_cast<bool>(iface & Interfaces::InternalSideUserObject))
      50           0 :     os << "|InternalSideUserObject";
      51           0 :   if (static_cast<bool>(iface & Interfaces::NodalUserObject))
      52           0 :     os << "|NodalUserObject";
      53           0 :   if (static_cast<bool>(iface & Interfaces::GeneralUserObject))
      54           0 :     os << "|GeneralUserObject";
      55           0 :   if (static_cast<bool>(iface & Interfaces::ThreadedGeneralUserObject))
      56           0 :     os << "|ThreadedGeneralUserObject";
      57           0 :   if (static_cast<bool>(iface & Interfaces::ShapeElementUserObject))
      58           0 :     os << "|ShapeElementUserObject";
      59           0 :   if (static_cast<bool>(iface & Interfaces::ShapeSideUserObject))
      60           0 :     os << "|ShapeSideUserObject";
      61           0 :   if (static_cast<bool>(iface & Interfaces::Postprocessor))
      62           0 :     os << "|Postprocessor";
      63           0 :   if (static_cast<bool>(iface & Interfaces::VectorPostprocessor))
      64           0 :     os << "|VectorPostprocessor";
      65           0 :   if (static_cast<bool>(iface & Interfaces::InterfaceUserObject))
      66           0 :     os << "|InterfaceUserObject";
      67           0 :   if (static_cast<bool>(iface & Interfaces::Reporter))
      68           0 :     os << "|Reporter";
      69           0 :   if (static_cast<bool>(iface & Interfaces::DomainUserObject))
      70           0 :     os << "|DomainUserObject";
      71           0 :   if (static_cast<bool>(iface & Interfaces::MortarUserObject))
      72           0 :     os << "|MortarUserObject";
      73           0 :   if (static_cast<bool>(iface & Interfaces::FVInterpolationMethod))
      74           0 :     os << "|FVInterpolationMethod";
      75           0 :   os << ")";
      76           0 :   return os;
      77             : }
      78             : 
      79             : bool
      80       40113 : AttribTagBase::isMatch(const Attribute & other) const
      81             : {
      82       40113 :   auto a = dynamic_cast<const AttribTagBase *>(&other);
      83       40113 :   if (!a)
      84           0 :     return false;
      85       40113 :   if (a->_vals.size() == 0)
      86           0 :     return true; // the condition is empty tags - which we take to mean any tag should match
      87             : 
      88             :   // return true if any single tag matches between the two attribute objects
      89       41143 :   for (auto val : _vals)
      90       40089 :     if (std::find(a->_vals.begin(), a->_vals.end(), val) != a->_vals.end())
      91       39059 :       return true;
      92        1054 :   return false;
      93             : }
      94             : 
      95             : bool
      96     7222885 : AttribTagBase::isEqual(const Attribute & other) const
      97             : {
      98     7222885 :   auto a = dynamic_cast<const AttribTagBase *>(&other);
      99     7222885 :   if (!a || a->_vals.size() != _vals.size())
     100           0 :     return false;
     101             : 
     102    24305341 :   for (size_t i = 0; i < a->_vals.size(); i++)
     103    17082456 :     if (a->_vals[i] != _vals[i])
     104           0 :       return false;
     105     7222885 :   return true;
     106             : }
     107             : 
     108             : void
     109      304660 : AttribMatrixTags::initFrom(const MooseObject * obj)
     110             : {
     111      304660 :   _vals.clear();
     112      304660 :   auto t = dynamic_cast<const TaggingInterface *>(obj);
     113      304660 :   if (t)
     114             :   {
     115      451596 :     for (auto & tag : t->getMatrixTags({}))
     116      269840 :       _vals.push_back(static_cast<int>(tag));
     117             :   }
     118      304660 : }
     119             : 
     120             : void
     121      304660 : AttribVectorTags::initFrom(const MooseObject * obj)
     122             : {
     123      304660 :   _vals.clear();
     124      304660 :   auto t = dynamic_cast<const TaggingInterface *>(obj);
     125      304660 :   if (t)
     126             :   {
     127      367131 :     for (auto & tag : t->getVectorTags({}))
     128      185375 :       _vals.push_back(static_cast<int>(tag));
     129             :   }
     130      304660 : }
     131             : 
     132             : void
     133      304660 : AttribExecOns::initFrom(const MooseObject * obj)
     134             : {
     135      304660 :   _vals.clear();
     136      304660 :   if (const auto sup = dynamic_cast<const SetupInterface *>(obj))
     137             :   {
     138      258983 :     const auto & current_items = sup->getExecuteOnEnum();
     139      258983 :     _vals.reserve(current_items.size());
     140      350480 :     for (auto & on : current_items)
     141       91497 :       _vals.push_back(on);
     142             :   }
     143      304660 : }
     144             : 
     145             : bool
     146     3087957 : AttribExecOns::isMatch(const Attribute & other) const
     147             : {
     148     3087957 :   auto a = dynamic_cast<const AttribExecOns *>(&other);
     149     3087957 :   if (!a || a->_vals.empty())
     150           0 :     return false;
     151     3087957 :   auto cond = a->_vals[0];
     152     3087957 :   if (cond == EXEC_ALL)
     153        1092 :     return true;
     154             : 
     155     5112675 :   for (const auto val : _vals)
     156     3677795 :     if (val == EXEC_ALL || val == cond)
     157     1651985 :       return true;
     158     1434880 :   return false;
     159             : }
     160             : 
     161             : bool
     162    32189536 : AttribExecOns::isEqual(const Attribute & other) const
     163             : {
     164    32189536 :   auto a = dynamic_cast<const AttribExecOns *>(&other);
     165    32189536 :   if (!a || a->_vals.size() != _vals.size())
     166           0 :     return false;
     167             : 
     168    64379072 :   for (size_t i = 0; i < a->_vals.size(); i++)
     169    32189536 :     if (a->_vals[i] != _vals[i])
     170           0 :       return false;
     171    32189536 :   return true;
     172             : }
     173             : 
     174             : void
     175      304660 : AttribSubdomains::initFrom(const MooseObject * obj)
     176             : {
     177      304660 :   _vals.clear();
     178      304660 :   auto blk = dynamic_cast<const BlockRestrictable *>(obj);
     179      304660 :   if (blk && blk->blockRestricted())
     180             :   {
     181       34256 :     for (auto id : blk->blockIDs())
     182       18861 :       _vals.push_back(id);
     183             :   }
     184             :   else
     185      289265 :     _vals.push_back(Moose::ANY_BLOCK_ID);
     186      304660 : }
     187             : 
     188             : bool
     189     1002569 : AttribSubdomains::isMatch(const Attribute & other) const
     190             : {
     191     1002569 :   auto a = dynamic_cast<const AttribSubdomains *>(&other);
     192     1002569 :   if (!a || a->_vals.size() < 1)
     193           0 :     return false;
     194             : 
     195     1002569 :   auto cond = a->_vals[0];
     196     1002569 :   if (cond == Moose::ANY_BLOCK_ID)
     197           0 :     return true;
     198     1002569 :   else if (cond == Moose::INVALID_BLOCK_ID)
     199        6546 :     return false;
     200             : 
     201     1128831 :   for (auto id : _vals)
     202             :   {
     203     1037845 :     if (id == cond || id == Moose::ANY_BLOCK_ID)
     204      905037 :       return true;
     205             :   }
     206       90986 :   return false;
     207             : }
     208             : 
     209             : bool
     210     5973565 : AttribSubdomains::isEqual(const Attribute & other) const
     211             : {
     212     5973565 :   auto a = dynamic_cast<const AttribSubdomains *>(&other);
     213     5973565 :   if (!a || a->_vals.size() != _vals.size())
     214           0 :     return false;
     215             : 
     216    11947130 :   for (size_t i = 0; i < a->_vals.size(); i++)
     217     5973565 :     if (a->_vals[i] != _vals[i])
     218           0 :       return false;
     219     5973565 :   return true;
     220             : }
     221             : 
     222             : void
     223      304660 : AttribBoundaries::initFrom(const MooseObject * obj)
     224             : {
     225      304660 :   _vals.clear();
     226      304660 :   auto bnd = dynamic_cast<const BoundaryRestrictable *>(obj);
     227      304660 :   if (bnd && bnd->boundaryRestricted())
     228             :   {
     229      207235 :     for (auto & bound : bnd->boundaryIDs())
     230      116535 :       _vals.push_back(bound);
     231             :   }
     232             :   else
     233      213960 :     _vals.push_back(Moose::ANY_BOUNDARY_ID);
     234      304660 : }
     235             : 
     236             : bool
     237      703994 : AttribBoundaries::isMatch(const Attribute & other) const
     238             : {
     239      703994 :   auto a = dynamic_cast<const AttribBoundaries *>(&other);
     240      703994 :   if (!a || a->_vals.size() < 1)
     241           0 :     return false;
     242             : 
     243             :   // return true if a single tag matches between the two attribute objects
     244      967015 :   for (auto val : _vals)
     245             :   {
     246      783115 :     if (!a->_must_be_restricted && (val == Moose::ANY_BOUNDARY_ID))
     247      520094 :       return true;
     248      347419 :     if (std::find(a->_vals.begin(), a->_vals.end(), val) != a->_vals.end())
     249       79520 :       return true;
     250      267899 :     else if (std::find(a->_vals.begin(), a->_vals.end(), Moose::ANY_BOUNDARY_ID) != a->_vals.end())
     251        4878 :       return true;
     252             :   }
     253      183900 :   return false;
     254             : }
     255             : 
     256             : bool
     257     9532052 : AttribBoundaries::isEqual(const Attribute & other) const
     258             : {
     259     9532052 :   auto a = dynamic_cast<const AttribBoundaries *>(&other);
     260     9532052 :   if (!a || a->_vals.size() != _vals.size())
     261           0 :     return false;
     262             : 
     263    19064104 :   for (size_t i = 0; i < a->_vals.size(); i++)
     264     9532052 :     if (a->_vals[i] != _vals[i])
     265           0 :       return false;
     266     9532052 :   return true;
     267             : }
     268             : 
     269             : void
     270      304660 : AttribThread::initFrom(const MooseObject * obj)
     271             : {
     272      609320 :   _val = obj->getParam<THREAD_ID>("_tid");
     273      304660 : }
     274             : bool
     275    24184982 : AttribThread::isMatch(const Attribute & other) const
     276             : {
     277    24184982 :   auto a = dynamic_cast<const AttribThread *>(&other);
     278    24184982 :   return a && (a->_val == _val);
     279             : }
     280             : bool
     281    21103041 : AttribThread::isEqual(const Attribute & other) const
     282             : {
     283    21103041 :   return isMatch(other);
     284             : }
     285             : 
     286             : void
     287      304660 : AttribExecutionOrderGroup::initFrom(const MooseObject * obj)
     288             : {
     289      304660 :   const auto * uo = dynamic_cast<const UserObjectBase *>(obj);
     290      378786 :   _val = uo ? uo->getParam<int>("execution_order_group") : 0;
     291      304660 : }
     292             : bool
     293    10170916 : AttribExecutionOrderGroup::isMatch(const Attribute & other) const
     294             : {
     295    10170916 :   auto a = dynamic_cast<const AttribExecutionOrderGroup *>(&other);
     296    10170916 :   return a && (a->_val == _val);
     297             : }
     298             : bool
     299     8765925 : AttribExecutionOrderGroup::isEqual(const Attribute & other) const
     300             : {
     301     8765925 :   return isMatch(other);
     302             : }
     303             : 
     304             : void
     305      304660 : AttribSysNum::initFrom(const MooseObject * obj)
     306             : {
     307      609320 :   auto * sys = obj->getParam<SystemBase *>("_sys");
     308             : 
     309      304660 :   if (sys)
     310      304231 :     _val = sys->number();
     311      304660 : }
     312             : 
     313             : bool
     314     8211947 : AttribSysNum::isMatch(const Attribute & other) const
     315             : {
     316     8211947 :   auto a = dynamic_cast<const AttribSysNum *>(&other);
     317     8211947 :   return a && (a->_val == _val);
     318             : }
     319             : 
     320             : bool
     321     7582768 : AttribSysNum::isEqual(const Attribute & other) const
     322             : {
     323     7582768 :   return isMatch(other);
     324             : }
     325             : 
     326             : void
     327      304660 : AttribPreIC::initFrom(const MooseObject * /*obj*/)
     328             : {
     329      304660 : }
     330             : bool
     331       15327 : AttribPreIC::isMatch(const Attribute & other) const
     332             : {
     333       15327 :   auto a = dynamic_cast<const AttribPreIC *>(&other);
     334       15327 :   return a && (a->_val == _val);
     335             : }
     336             : 
     337             : bool
     338          61 : AttribPreIC::isEqual(const Attribute & other) const
     339             : {
     340          61 :   return isMatch(other);
     341             : }
     342             : 
     343             : bool
     344      176027 : AttribPreAux::isMatch(const Attribute & other) const
     345             : {
     346      176027 :   const auto a = dynamic_cast<const AttribPreAux *>(&other);
     347             : 
     348      176027 :   bool is_match = false;
     349             : 
     350      176027 :   if (a && !_vals.empty() && !a->_vals.empty())
     351             :   {
     352       55598 :     is_match = std::includes(_vals.begin(), _vals.end(), a->_vals.begin(), a->_vals.end()) ||
     353        3954 :                std::includes(a->_vals.begin(), a->_vals.end(), _vals.begin(), _vals.end());
     354             :   }
     355             : 
     356      176027 :   return is_match;
     357             : }
     358             : 
     359             : bool
     360     9179078 : AttribPreAux::isEqual(const Attribute & other) const
     361             : {
     362     9179078 :   const auto a = dynamic_cast<const AttribPreAux *>(&other);
     363     9179078 :   return a && a->_vals == _vals;
     364             : }
     365             : 
     366             : void
     367      304660 : AttribPreAux::initFrom(const MooseObject * /*obj*/)
     368             : {
     369      304660 : }
     370             : 
     371             : bool
     372     1458620 : AttribPostAux::isMatch(const Attribute & other) const
     373             : {
     374     1458620 :   const auto a = dynamic_cast<const AttribPostAux *>(&other);
     375             : 
     376     1458620 :   bool is_match = false;
     377             : 
     378     1458620 :   if (a && !_vals.empty() && !a->_vals.empty())
     379             :   {
     380     1465598 :     is_match = std::includes(_vals.begin(), _vals.end(), a->_vals.begin(), a->_vals.end()) ||
     381       11832 :                std::includes(a->_vals.begin(), a->_vals.end(), _vals.begin(), _vals.end());
     382             :   }
     383             : 
     384     1458620 :   return is_match;
     385             : }
     386             : 
     387             : bool
     388    17609674 : AttribPostAux::isEqual(const Attribute & other) const
     389             : {
     390    17609674 :   const auto a = dynamic_cast<const AttribPostAux *>(&other);
     391    17609674 :   return a && a->_vals == _vals;
     392             : }
     393             : 
     394             : void
     395      304660 : AttribPostAux::initFrom(const MooseObject * /*obj*/)
     396             : {
     397      304660 : }
     398             : 
     399             : void
     400      304660 : AttribName::initFrom(const MooseObject * obj)
     401             : {
     402      304660 :   _val = obj->name();
     403      304660 : }
     404             : bool
     405     1489740 : AttribName::isMatch(const Attribute & other) const
     406             : {
     407     1489740 :   auto a = dynamic_cast<const AttribName *>(&other);
     408     1489740 :   return a && (a->_val == _val);
     409             : }
     410             : 
     411             : bool
     412     1263650 : AttribName::isEqual(const Attribute & other) const
     413             : {
     414     1263650 :   return isMatch(other);
     415             : }
     416             : 
     417             : void
     418      304660 : AttribSystem::initFrom(const MooseObject * obj)
     419             : {
     420      304660 :   _val = obj->parameters().getSystemAttributeName();
     421      304660 : }
     422             : 
     423             : bool
     424    70205387 : AttribSystem::isMatch(const Attribute & other) const
     425             : {
     426    70205387 :   auto a = dynamic_cast<const AttribSystem *>(&other);
     427    70205387 :   return a && (a->_val == _val);
     428             : }
     429             : 
     430             : bool
     431    48541755 : AttribSystem::isEqual(const Attribute & other) const
     432             : {
     433    48541755 :   return isMatch(other);
     434             : }
     435             : 
     436             : void
     437      304660 : AttribResidualObject::initFrom(const MooseObject * obj)
     438             : {
     439      609320 :   _val = obj->getParam<bool>("_residual_object");
     440      304660 :   _initd = true;
     441      304660 : }
     442             : 
     443             : bool
     444           0 : AttribResidualObject::isMatch(const Attribute & other) const
     445             : {
     446           0 :   auto a = dynamic_cast<const AttribResidualObject *>(&other);
     447           0 :   return _initd && a && a->_initd && (a->_val == _val);
     448             : }
     449             : 
     450             : bool
     451           0 : AttribResidualObject::isEqual(const Attribute & other) const
     452             : {
     453           0 :   return isMatch(other);
     454             : }
     455             : 
     456             : void
     457      304660 : AttribVar::initFrom(const MooseObject * obj)
     458             : {
     459      304660 :   auto vi = dynamic_cast<const MooseVariableInterface<Real> *>(obj);
     460      304660 :   if (vi)
     461      205335 :     _val = static_cast<int>(vi->mooseVariableBase()->number());
     462      304660 : }
     463             : bool
     464      186587 : AttribVar::isMatch(const Attribute & other) const
     465             : {
     466      186587 :   auto a = dynamic_cast<const AttribVar *>(&other);
     467      186587 :   return a && (_val != -1) && (a->_val == _val);
     468             : }
     469             : 
     470             : bool
     471      127596 : AttribVar::isEqual(const Attribute & other) const
     472             : {
     473      127596 :   return isMatch(other);
     474             : }
     475             : 
     476             : void
     477      304660 : AttribInterfaces::initFrom(const MooseObject * obj)
     478             : {
     479      304660 :   _val = 0;
     480             :   // clang-format off
     481      304660 :   _val |= (unsigned int)Interfaces::UserObject                * (dynamic_cast<const UserObjectBase *>(obj) != nullptr);
     482      304660 :   _val |= (unsigned int)Interfaces::ElementUserObject         * (dynamic_cast<const ElementUserObject *>(obj) != nullptr);
     483      304660 :   _val |= (unsigned int)Interfaces::SideUserObject            * (dynamic_cast<const SideUserObject *>(obj) != nullptr);
     484      304660 :   _val |= (unsigned int)Interfaces::InternalSideUserObject    * (dynamic_cast<const InternalSideUserObject *>(obj) != nullptr);
     485      304660 :   _val |= (unsigned int)Interfaces::InterfaceUserObject       * (dynamic_cast<const InterfaceUserObject *>(obj) != nullptr);
     486      304660 :   _val |= (unsigned int)Interfaces::NodalUserObject           * (dynamic_cast<const NodalUserObject *>(obj) != nullptr);
     487      304660 :   _val |= (unsigned int)Interfaces::GeneralUserObject         * (dynamic_cast<const GeneralUserObject *>(obj) != nullptr);
     488      304660 :   _val |= (unsigned int)Interfaces::ThreadedGeneralUserObject * (dynamic_cast<const ThreadedGeneralUserObject *>(obj) != nullptr);
     489      304660 :   _val |= (unsigned int)Interfaces::ShapeElementUserObject    * (dynamic_cast<const ShapeElementUserObject *>(obj) != nullptr);
     490      304660 :   _val |= (unsigned int)Interfaces::ShapeSideUserObject       * (dynamic_cast<const ShapeSideUserObject *>(obj) != nullptr);
     491      304660 :   _val |= (unsigned int)Interfaces::Postprocessor             * (dynamic_cast<const Postprocessor *>(obj) != nullptr);
     492      304660 :   _val |= (unsigned int)Interfaces::VectorPostprocessor       * (dynamic_cast<const VectorPostprocessor *>(obj) != nullptr);
     493      304660 :   _val |= (unsigned int)Interfaces::BlockRestrictable         * (dynamic_cast<const BlockRestrictable *>(obj) != nullptr);
     494      304660 :   _val |= (unsigned int)Interfaces::BoundaryRestrictable      * (dynamic_cast<const BoundaryRestrictable *>(obj) != nullptr);
     495      304660 :   _val |= (unsigned int)Interfaces::Reporter                  * (dynamic_cast<const Reporter *>(obj) != nullptr);
     496      304660 :   _val |= (unsigned int)Interfaces::DomainUserObject          * (dynamic_cast<const DomainUserObject *>(obj) != nullptr);
     497      304660 :   _val |= (unsigned int)Interfaces::MortarUserObject          * (dynamic_cast<const MortarUserObject *>(obj) != nullptr);
     498      304660 :   _val |= (unsigned int)Interfaces::FVInterpolationMethod     * (dynamic_cast<const FVInterpolationMethod *>(obj) != nullptr);
     499             :   // clang-format on
     500      304660 : }
     501             : 
     502             : bool
     503     5198272 : AttribInterfaces::isMatch(const Attribute & other) const
     504             : {
     505     5198272 :   auto a = dynamic_cast<const AttribInterfaces *>(&other);
     506     5198272 :   return a && (a->_val & _val);
     507             : }
     508             : 
     509             : bool
     510    14079365 : AttribInterfaces::isEqual(const Attribute & other) const
     511             : {
     512    14079365 :   auto a = dynamic_cast<const AttribInterfaces *>(&other);
     513    14079365 :   return a && (a->_val == _val);
     514             : }
     515             : 
     516             : void
     517      304660 : AttribDisplaced::initFrom(const MooseObject * obj)
     518             : {
     519      558478 :   _val = obj->parameters().have_parameter<bool>("use_displaced_mesh") &&
     520      812296 :          obj->getParam<bool>("use_displaced_mesh");
     521      304660 : }
     522             : 
     523             : bool
     524     6986757 : AttribDisplaced::isMatch(const Attribute & other) const
     525             : {
     526     6986757 :   auto a = dynamic_cast<const AttribDisplaced *>(&other);
     527     6986757 :   return a && (a->_val == _val);
     528             : }
     529             : 
     530             : bool
     531     6945849 : AttribDisplaced::isEqual(const Attribute & other) const
     532             : {
     533     6945849 :   return isMatch(other);
     534             : }