How can I get the material property in ADNodalBC?

[Always-kimi]

Check these boxes if you have followed the posting rules.

• Q&A General is the most appropriate section for my question
• I have consulted the posting Guidelines on the Discussions front page
• I have searched the Discussions forum and my question has not been asked before
• I have searched the MOOSE website and the documentation does not answer my question
• I have formatted my post following the posting guidelines (screenshots as a last resort, triple back quotes around pasted text)

Question

Hi there,

I have some puzzle about ADNodalBC and ADIntergratedBC.
In my application, I need add some material properties or functions to calculate residual, in the ADIntergratedBC, I can easily call the getADMaterialProperty<Real>("mu") method.
However when I used the getADMaterialProperty<Real>("mu") method in the ADNodalBC, the compiler show the error:

Creating Unity /home/kimi/projects/validation/build/unity_src/bcs_Unity.C
Compiling C++ (in opt mode) /home/kimi/projects/validation/build/unity_src/bcs_Unity.C...
In file included from /home/kimi/projects/validation/build/unity_src/bcs_Unity.C:3:
/home/kimi/projects/validation/src/bcs/MassBC.C: In constructor 'MassBC::MassBC(const InputParameters&)':
/home/kimi/projects/validation/src/bcs/MassBC.C:39:9: error: 'getADMaterialProperty' was not declared in this scope; did you mean 'ADMaterialProperty'?
   39 |     _mu(getADMaterialProperty<Real>("mu"))
      |         ^~~~~~~~~~~~~~~~~~~~~
      |         ADMaterialProperty
/home/kimi/projects/validation/src/bcs/MassBC.C:39:35: error: expected primary-expression before '>' token
   39 |     _mu(getADMaterialProperty<Real>("mu"))
      |                                   ^
make: *** [/home/kimi/projects/moose/framework/build.mk:151: /home/kimi/projects/validation/build/unity_src/bcs_Unity.x86_64-conda-linux-gnu.opt.lo] Error 1

my .h file and .C file were listed below:

#pragma once

#include "ADNodalBC.h"

/**
 * Increments the boundary displacement by the product of the surface velocity and the change in
 * time through an implicit Euler disretization
 */
class MassBC : public ADNodalBC
{
public:
  static InputParameters validParams();

  MassBC(const InputParameters & parameters);

protected:
  virtual ADReal computeQpResidual() override;

  /// The velocity
  const Moose::Functor<ADRealVectorValue> & _velocity;

  /// The previous timestep value of the displacement
  const Real & _u_old;

  /// What component of velocity/displacement this object is acting on
  const unsigned short _component;

  /// The subdomain ID along which the boundary nodeset, that this object is acting on, is
  /// associated with
  const SubdomainID _sub_id;

  const MooseArray<ADPoint> & _ad_normals;

  ADMaterialProperty<Real> & _mu;
};

#include "MassBC.h"
#include "SystemBase.h"
#include "ImplicitEuler.h"

registerMooseObject("ValidationApp", MassBC);

InputParameters
MassBC::validParams()
{
  InputParameters params = ADNodalBC::validParams();
  params.addClassDescription("Boundary condition for displacing a boundary");
  params.addRequiredParam<MooseFunctorName>("velocity", "The velocity at which to displace");
  params.addRequiredParam<unsigned short>(
      "component", "What component of velocity/displacement this object is acting on.");
  params.addRequiredParam<SubdomainName>(
      "associated_subdomain",
      "The subdomain that the boundary nodeset is associated with. This will be passed to the "
      "coupled functor for unambigious evaluation (e.g. at the edge of the node-patch where we "
      "might run into the intersection of subdomains");
  return params;
}

MassBC::MassBC(const InputParameters & parameters)
  : ADNodalBC(parameters),
    _velocity(getFunctor<ADRealVectorValue>("velocity")),
    _u_old(_var.nodalValueOld()),
    _component(getParam<unsigned short>("component")),
    _sub_id(_mesh.getSubdomainID(getParam<SubdomainName>("associated_subdomain"))),
    _ad_normals(_assembly.adNormals()),
    _mu(getADMaterialProperty<Real>("mu"))
{
  if (!dynamic_cast<ImplicitEuler *>(_sys.getTimeIntegrator()))
    mooseError("This boundary condition hard-codes a displacement update with the form of an "
               "implicit Euler discretization. Consequently please use the default time "
               "integrator, ImplicitEuler.");
}

ADReal
MassBC::computeQpResidual()
{
  const Moose::NodeArg nd{_current_node, _sub_id};
  return _u - (_u_old + this->_dt * (_velocity(nd, determineState())(_component) - _mu[_qp] * _ad_normals[_qp](_component)));
}

How can I get the material property correctly in ADNodalBC?

[GiudGiud]

Hello

There are no "nodal" material property with the traditional material property system, because we cannot know which block's definition of a material property to use at a node at the boundary between two blocks

You could use the functor materials, a new type of material properties that get evaluated on-the-fly, instead. This will require converting your material properties to the new system.

[Always-kimi]

Thank you! I got it. Actually, I try to imported the function system to ADNodalBC for calculate but it also show some errors. Is there any example or page I can learn from in developing ADNodalBC?

[GiudGiud]

we dont have a dedicated tutorial for nodal BCs

however the doxygen should be very helpful, listing all the examples of that type of BC and listing all the APIs you can use
https://mooseframework.inl.gov/docs/doxygen/moose/classGenericNodalBC_3_01true_01_4.html

the examples can be found through "grep" in the src folders actually, seems the doxygen isnt listing them

[Always-kimi]

Thank you very much!

[Always-kimi]

Hi Guillaume,

@GiudGiud Sorry to bother you again! At your suggestion, I built my own functor materials. Despite my best efforts, however, I ended up getting stuck on getting the nodal coordinates. My source file of the functor material was listed as follow:

#include "MassAdditionFunctorMaterial.h"
#include "Function.h"

registerMooseObject("ValidationApp", MassAdditionFunctorMaterial);

InputParameters
MassAdditionFunctorMaterial::validParams()
{
  InputParameters params = FunctorMaterial::validParams();
  params.addClassDescription("Calculates the boundary condition residual contribution of the powder "
                             "flux of a Gaussian laser powder impinging on a surface.");
  params.addRequiredParam<Real>("eta",
                                "The effective radius describing the radial distribution of the "
                                "powder energy. This should be non-dimensional.");
  params.addRequiredParam<Real>("M0", "The average heat flux of the laser");
  params.addRequiredParam<Real>("R", "The powder radius");
  params.addParam<FunctionName>("x_powder_coord", 0, "The x coordinate of the center of the powder");
  params.addParam<FunctionName>("y_powder_coord", 0, "The y coordinate of the center of the powder");
  params.addParam<FunctionName>("z_powder_coord", 0, "The z coordinate of the center of the powder");
  return params;
}

MassAdditionFunctorMaterial::MassAdditionFunctorMaterial(const InputParameters & params)
  : FunctorMaterial(params),
    _eta(getParam<Real>("eta")),
    _M0(getParam<Real>("M0")),
    _R(getParam<Real>("R")),
    _x_powder_coord(getFunction("x_powder_coord")),
    _y_powder_coord(getFunction("y_powder_coord")),
    _z_powder_coord(getFunction("z_powder_coord"))
{
  addFunctorProperty<ADReal>(
      "mass_flow",
      [this](const auto & r, const auto & t)
      {
        RealVectorValue powder_coords{_x_powder_coord(r, t),
                                      _y_powder_coord(r, t),
                                      _z_powder_coord(r, t)};
        auto R = (_q_point[_qp] - powder_coords).norm();  
        return 2. * _eta * _M0 * std::exp(-_eta * R * R / (_R * _R));
      });
}

The file can be compile and there is nothing warning. At first the simulation is enable executing, but then the error message come out with Segmentation fault (core dumped):

(moose) kimi@DESKTOP-7APSM1S:~/projects/validation/problems$ ../validation-opt -i 3d_mass_flux.i
The following total 1 aux variables:
  mu
are added for automatic output by MaterialOutputAction.
Framework Information:
MOOSE Version:           git commit f3d6fc1a05 on 2024-05-25
LibMesh Version:
PETSc Version:           3.20.3
SLEPc Version:           3.20.1
Current Time:            Thu Jun 13 14:49:32 2024
Executable Timestamp:    Thu Jun 13 14:49:03 2024

Parallelism:
  Num Processors:          1
  Num Threads:             1

Mesh:
  Parallel Type:           replicated
  Mesh Dimension:          3
  Spatial Dimension:       3
  Nodes:                   729
  Elems:                   512
  Num Subdomains:          1

Nonlinear System:
  Num DOFs:                5832
  Num Local DOFs:          5832
  Variables:               "vel" { "T" "p" "disp_x" "disp_y" "disp_z" }
  Finite Element Types:    "LAGRANGE_VEC" "LAGRANGE"
  Approximation Orders:    "FIRST" "FIRST"

Auxiliary System:
  Num DOFs:                3072
  Num Local DOFs:          3072
  Variables:               { "error_T" "error_dispz" "errorfrac_T" "errorfrac_dispz" "combo" "mu" }
  Finite Element Types:    "MONOMIAL"
  Approximation Orders:    "CONSTANT"

Execution Information:
  Executioner:             Transient
  TimeStepper:             IterationAdaptiveDT
  TimeIntegrator:          ImplicitEuler
  Solver Mode:             NEWTON
  PETSc Preconditioner:    lu
  MOOSE Preconditioner:    SMP


Time Step 0, time = 0

Postprocessor Values:
+----------------+----------------+----------------+----------------+
| time           | nl             | num_dofs       | tot_nl         |
+----------------+----------------+----------------+----------------+
|   0.000000e+00 |   0.000000e+00 |   0.000000e+00 |   0.000000e+00 |
+----------------+----------------+----------------+----------------+


Time Step 1, time = 6e-06, dt = 6e-06
Segmentation fault (core dumped)

After testing my codes, the problem seems to be with the second last code auto R = (_q_point[_qp] - powder_coords).norm(); and I cannot to get the correct _q_point[_qp]. If I remove the _q_point[_qp] code, the simulation is well executing. Do you know how to solve this problem?

[GiudGiud]

_q_point should not be used here.

use r (the spatial argument) instread.
You can see the list of spatial arguments in MooseFunctorArguments.h.
From there, you can add code like in the FunctorSmoother to specialize how you retrieve the location to each spatial argument