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             : #ifdef MOOSE_MFEM_ENABLED
      11             : 
      12             : #include "MFEMExecutedObject.h"
      13             : 
      14             : InputParameters
      15       68764 : MFEMExecutedObject::validParams()
      16             : {
      17       68764 :   InputParameters params = MFEMObject::validParams();
      18       68764 :   params += SetupInterface::validParams();
      19       68764 :   params.registerSystemAttributeName("MFEMExecutedObject");
      20      206292 :   params.addPrivateParam<std::vector<std::string>>("_mfem_dependency_param_names", {});
      21      137528 :   params.set<ExecFlagEnum>("execute_on", true) = EXEC_TIMESTEP_END;
      22       68764 :   params.addClassDescription("Base class for executed MFEM objects.");
      23       68764 :   return params;
      24           0 : }
      25             : 
      26        2912 : MFEMExecutedObject::MFEMExecutedObject(const InputParameters & parameters)
      27        2912 :   : MFEMObject(parameters), SetupInterface(this), DependencyResolverInterface()
      28             : {
      29        2912 : }
      30             : 
      31             : std::optional<std::string>
      32        1059 : MFEMExecutedObject::suppliedVariableName() const
      33             : {
      34        1059 :   return std::nullopt;
      35             : }
      36             : 
      37             : std::optional<std::string>
      38        2151 : MFEMExecutedObject::suppliedPostprocessorName() const
      39             : {
      40        2151 :   return std::nullopt;
      41             : }
      42             : 
      43             : std::optional<std::string>
      44        2554 : MFEMExecutedObject::suppliedVectorPostprocessorName() const
      45             : {
      46        2554 :   return std::nullopt;
      47             : }
      48             : 
      49             : const std::set<std::string> &
      50        2120 : MFEMExecutedObject::getRequestedItems()
      51             : {
      52        2120 :   if (_requested_items)
      53           0 :     return *_requested_items;
      54             : 
      55        2120 :   _requested_items.emplace();
      56             : 
      57        7679 :   for (const auto & param : getParam<std::vector<std::string>>("_mfem_dependency_param_names"))
      58             :   {
      59        1319 :     if (const auto * name = queryParam<VariableName>(param))
      60        1254 :       _requested_items->insert(variableDependencyKey(*name));
      61        1319 :     if (const auto * names = queryParam<std::vector<VariableName>>(param))
      62         171 :       for (const auto & name : *names)
      63         114 :         _requested_items->insert(variableDependencyKey(name));
      64        1319 :     if (const auto * name = queryParam<PostprocessorName>(param))
      65           2 :       _requested_items->insert(postprocessorDependencyKey(*name));
      66        1319 :     if (const auto * names = queryParam<std::vector<PostprocessorName>>(param))
      67           0 :       for (const auto & name : *names)
      68           0 :         _requested_items->insert(postprocessorDependencyKey(name));
      69        1319 :     if (const auto * name = queryParam<VectorPostprocessorName>(param))
      70           0 :       _requested_items->insert(vectorPostprocessorDependencyKey(*name));
      71        1319 :     if (const auto * names = queryParam<std::vector<VectorPostprocessorName>>(param))
      72           0 :       for (const auto & name : *names)
      73           0 :         _requested_items->insert(vectorPostprocessorDependencyKey(name));
      74             :   }
      75             : 
      76        2120 :   return *_requested_items;
      77             : }
      78             : 
      79             : const std::set<std::string> &
      80        5980 : MFEMExecutedObject::getSuppliedItems()
      81             : {
      82        5980 :   if (_supplied_items)
      83        3098 :     return *_supplied_items;
      84             : 
      85        2882 :   _supplied_items.emplace();
      86             : 
      87        2882 :   if (const auto name = suppliedVariableName())
      88        2882 :     _supplied_items->insert(variableDependencyKey(*name));
      89        2882 :   if (const auto name = suppliedPostprocessorName())
      90        2882 :     _supplied_items->insert(postprocessorDependencyKey(*name));
      91        2882 :   if (const auto name = suppliedVectorPostprocessorName())
      92        2882 :     _supplied_items->insert(vectorPostprocessorDependencyKey(*name));
      93             : 
      94        2882 :   return *_supplied_items;
      95             : }
      96             : 
      97             : std::string
      98        3191 : MFEMExecutedObject::variableDependencyKey(const std::string & name)
      99             : {
     100        3191 :   return "variable:" + name;
     101             : }
     102             : 
     103             : std::string
     104         733 : MFEMExecutedObject::postprocessorDependencyKey(const std::string & name)
     105             : {
     106         733 :   return "postprocessor:" + name;
     107             : }
     108             : 
     109             : std::string
     110         328 : MFEMExecutedObject::vectorPostprocessorDependencyKey(const std::string & name)
     111             : {
     112         328 :   return "vector_postprocessor:" + name;
     113             : }
     114             : 
     115             : void
     116       49780 : MFEMExecutedObject::appendDependencyParam(InputParameters & params, const std::string & param_name)
     117             : {
     118       49780 :   auto & param_names = params.set<std::vector<std::string>>("_mfem_dependency_param_names");
     119       49780 :   param_names.push_back(param_name);
     120       49780 : }
     121             : 
     122             : #endif