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       68172 : MFEMExecutedObject::validParams()
      16             : {
      17       68172 :   InputParameters params = MFEMObject::validParams();
      18       68172 :   params += SetupInterface::validParams();
      19       68172 :   params.registerSystemAttributeName("MFEMExecutedObject");
      20      204516 :   params.addPrivateParam<std::vector<std::string>>("_mfem_dependency_param_names", {});
      21      136344 :   params.set<ExecFlagEnum>("execute_on", true) = EXEC_TIMESTEP_END;
      22       68172 :   params.addClassDescription("Base class for executed MFEM objects.");
      23       68172 :   return params;
      24           0 : }
      25             : 
      26        2616 : MFEMExecutedObject::MFEMExecutedObject(const InputParameters & parameters)
      27        2616 :   : MFEMObject(parameters), SetupInterface(this), DependencyResolverInterface()
      28             : {
      29        2616 : }
      30             : 
      31             : std::optional<std::string>
      32         861 : MFEMExecutedObject::suppliedVariableName() const
      33             : {
      34         861 :   return std::nullopt;
      35             : }
      36             : 
      37             : std::optional<std::string>
      38        2031 : MFEMExecutedObject::suppliedPostprocessorName() const
      39             : {
      40        2031 :   return std::nullopt;
      41             : }
      42             : 
      43             : std::optional<std::string>
      44        2280 : MFEMExecutedObject::suppliedVectorPostprocessorName() const
      45             : {
      46        2280 :   return std::nullopt;
      47             : }
      48             : 
      49             : const std::set<std::string> &
      50        1880 : MFEMExecutedObject::getRequestedItems()
      51             : {
      52        1880 :   if (_requested_items)
      53           0 :     return *_requested_items;
      54             : 
      55        1880 :   _requested_items.emplace();
      56             : 
      57        6722 :   for (const auto & param : getParam<std::vector<std::string>>("_mfem_dependency_param_names"))
      58             :   {
      59        1082 :     if (const auto * name = queryParam<VariableName>(param))
      60        1024 :       _requested_items->insert(variableDependencyKey(*name));
      61        1082 :     if (const auto * names = queryParam<std::vector<VariableName>>(param))
      62         150 :       for (const auto & name : *names)
      63         100 :         _requested_items->insert(variableDependencyKey(name));
      64        1082 :     if (const auto * name = queryParam<PostprocessorName>(param))
      65           2 :       _requested_items->insert(postprocessorDependencyKey(*name));
      66        1082 :     if (const auto * names = queryParam<std::vector<PostprocessorName>>(param))
      67           0 :       for (const auto & name : *names)
      68           0 :         _requested_items->insert(postprocessorDependencyKey(name));
      69        1082 :     if (const auto * name = queryParam<VectorPostprocessorName>(param))
      70           0 :       _requested_items->insert(vectorPostprocessorDependencyKey(*name));
      71        1082 :     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        1880 :   return *_requested_items;
      77             : }
      78             : 
      79             : const std::set<std::string> &
      80        4940 : MFEMExecutedObject::getSuppliedItems()
      81             : {
      82        4940 :   if (_supplied_items)
      83        2354 :     return *_supplied_items;
      84             : 
      85        2586 :   _supplied_items.emplace();
      86             : 
      87        2586 :   if (const auto name = suppliedVariableName())
      88        2586 :     _supplied_items->insert(variableDependencyKey(*name));
      89        2586 :   if (const auto name = suppliedPostprocessorName())
      90        2586 :     _supplied_items->insert(postprocessorDependencyKey(*name));
      91        2586 :   if (const auto name = suppliedVectorPostprocessorName())
      92        2586 :     _supplied_items->insert(vectorPostprocessorDependencyKey(*name));
      93             : 
      94        2586 :   return *_supplied_items;
      95             : }
      96             : 
      97             : std::string
      98        2849 : MFEMExecutedObject::variableDependencyKey(const std::string & name)
      99             : {
     100        2849 :   return "variable:" + name;
     101             : }
     102             : 
     103             : std::string
     104         557 : MFEMExecutedObject::postprocessorDependencyKey(const std::string & name)
     105             : {
     106         557 :   return "postprocessor:" + name;
     107             : }
     108             : 
     109             : std::string
     110         306 : MFEMExecutedObject::vectorPostprocessorDependencyKey(const std::string & name)
     111             : {
     112         306 :   return "vector_postprocessor:" + name;
     113             : }
     114             : 
     115             : void
     116       49174 : MFEMExecutedObject::appendDependencyParam(InputParameters & params, const std::string & param_name)
     117             : {
     118       49174 :   auto & param_names = params.set<std::vector<std::string>>("_mfem_dependency_param_names");
     119       49174 :   param_names.push_back(param_name);
     120       49174 : }
     121             : 
     122             : #endif