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;

  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." : ""));
  }
}