ParsedAux.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
 
#include "AuxKernel.h"
#include "FunctionParserUtils.h"
 
class ParsedAux : public AuxKernel, public FunctionParserUtils<false>
{
public:
  static InputParameters validParams();
 
  ParsedAux(const InputParameters & parameters);
 
protected:
  virtual Real computeValue() override;
 
  void validateFunctorSymbols();
 
  void validateFunctorNames();
 
  template <typename T>
  void validateGenericVectorNames(const std::vector<T> & names_vec, const std::string & param_name);
 
  std::string _function;
 
  const unsigned int _nargs;
  const std::vector<const VariableValue *> _args;
 
  const std::vector<MaterialPropertyName> & _matprop_names;
  const std::vector<MaterialPropertyName> & _ad_matprop_names;
  const unsigned int _n_matprops;
  const unsigned int _n_ad_matprops;
  std::vector<const MaterialProperty<Real> *> _matprops;
  std::vector<const ADMaterialProperty<Real> *> _ad_matprops;
 
  const bool _use_xyzt;
 
  const std::vector<std::string> _xyzt;
 
  SymFunctionPtr _func_F;
 
  usingFunctionParserUtilsMembers(false);
 
  const std::vector<MooseFunctorName> & _functor_names;
 
  const unsigned int _n_functors;
 
  const std::vector<std::string> _functor_symbols;
 
  std::vector<const Moose::Functor<Real> *> _functors;
 
  const bool _use_qp_functor_arguments;
 
  std::vector<std::string> _coupled_variable_names;
};
 
template <typename T>
void
ParsedAux::validateGenericVectorNames(const std::vector<T> & names_vec,
                                      const std::string & param_name)
{
  for (const auto & name : names_vec)
  {
    // Make sure symbol is not x, y, z, or t
    if (_use_xyzt && (std::find(_xyzt.begin(), _xyzt.end(), name) != _xyzt.end()))
      paramError(
          param_name,
          "x, y, z, and t cannot be used in '" + param_name + "' when use_xyzt=true." +
              (param_name == "functor_names" ? " Use 'functor_symbols' to disambiguate." : ""));
    // Make sure symbol is not a coupled variable name
    if (_coupled_variable_names.size() &&
        (std::find(_coupled_variable_names.begin(), _coupled_variable_names.end(), name) !=
         _coupled_variable_names.end()))
      paramError(
          param_name,
          "Values in '" + param_name + "' cannot overlap with coupled variable names." +
              (param_name == "functor_names" ? " Use 'functor_symbols' to disambiguate." : ""));
  }
}