diff --git a/include/bcs/DisplaceBoundaryBC.h b/include/bcs/DisplaceBoundaryBC.h
new file mode 100644
index 00000000..4ba0484b
--- /dev/null
+++ b/include/bcs/DisplaceBoundaryBC.h
@@ -0,0 +1,35 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef DISPLACEBOUNDARYBC_H
+#define DISPLACEBOUNDARYBC_H
+
+#include "ADNodalBC.h"
+
+template <ComputeStage compute_stage>
+class DisplaceBoundaryBC;
+
+declareADValidParams(DisplaceBoundaryBC);
+
+template <ComputeStage compute_stage>
+class DisplaceBoundaryBC : public ADNodalBC<compute_stage>
+{
+public:
+  DisplaceBoundaryBC(const InputParameters & parameters);
+
+protected:
+  virtual typename Moose::RealType<compute_stage>::type computeQpResidual() override;
+
+  usingNodalBCMembers;
+
+  const typename Moose::RealType<compute_stage>::type & _velocity;
+  const Real & _u_old;
+};
+
+#endif /* DISPLACEBOUNDARYBC_H */
diff --git a/include/bcs/GaussianWeldEnergyFluxBC.h b/include/bcs/GaussianWeldEnergyFluxBC.h
new file mode 100644
index 00000000..d6c86fe0
--- /dev/null
+++ b/include/bcs/GaussianWeldEnergyFluxBC.h
@@ -0,0 +1,39 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef GAUSSIANWELDENERGYFLUXBC_H
+#define GAUSSIANWELDENERGYFLUXBC_H
+
+#include "ADIntegratedBC.h"
+
+template <ComputeStage>
+class GaussianWeldEnergyFluxBC;
+
+declareADValidParams(GaussianWeldEnergyFluxBC);
+
+template <ComputeStage compute_stage>
+class GaussianWeldEnergyFluxBC : public ADIntegratedBC<compute_stage>
+{
+public:
+  GaussianWeldEnergyFluxBC(const InputParameters & params);
+
+protected:
+  virtual ADResidual computeQpResidual() override;
+
+  const Real _reff;
+  const Real _F0;
+  const Real _R;
+  Function & _x_beam_coord;
+  Function & _y_beam_coord;
+  Function & _z_beam_coord;
+
+  usingIntegratedBCMembers;
+};
+
+#endif /* GAUSSIANWELDENERGYFLUXBC_H */
diff --git a/include/bcs/PenaltyDisplaceBoundaryBC.h b/include/bcs/PenaltyDisplaceBoundaryBC.h
new file mode 100644
index 00000000..6f3eb8b6
--- /dev/null
+++ b/include/bcs/PenaltyDisplaceBoundaryBC.h
@@ -0,0 +1,40 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef PENALTYDISPLACEBOUNDARYBC_H
+#define PENALTYDISPLACEBOUNDARYBC_H
+
+#include "ADIntegratedBC.h"
+
+template <ComputeStage compute_stage>
+class PenaltyDisplaceBoundaryBC;
+
+declareADValidParams(PenaltyDisplaceBoundaryBC);
+
+template <ComputeStage compute_stage>
+class PenaltyDisplaceBoundaryBC : public ADIntegratedBC<compute_stage>
+{
+public:
+  PenaltyDisplaceBoundaryBC(const InputParameters & parameters);
+
+protected:
+  virtual typename Moose::RealType<compute_stage>::type computeQpResidual() override;
+
+  usingIntegratedBCMembers;
+
+  const ADVariableValue & _vel_x;
+  const ADVariableValue & _vel_y;
+  const ADVariableValue & _vel_z;
+  const ADVariableValue & _disp_x_dot;
+  const ADVariableValue & _disp_y_dot;
+  const ADVariableValue & _disp_z_dot;
+  const Real _penalty;
+};
+
+#endif /* PENALTYDISPLACEBOUNDARYBC_H */
diff --git a/include/bcs/RadiationEnergyFluxBC.h b/include/bcs/RadiationEnergyFluxBC.h
new file mode 100644
index 00000000..e4508dcc
--- /dev/null
+++ b/include/bcs/RadiationEnergyFluxBC.h
@@ -0,0 +1,36 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef RADIATIONENERGYFLUXBC_H
+#define RADIATIONENERGYFLUXBC_H
+
+#include "ADIntegratedBC.h"
+
+template <ComputeStage compute_stage>
+class RadiationEnergyFluxBC;
+
+declareADValidParams(RadiationEnergyFluxBC);
+
+template <ComputeStage compute_stage>
+class RadiationEnergyFluxBC : public ADIntegratedBC<compute_stage>
+{
+public:
+  RadiationEnergyFluxBC(const InputParameters & parameters);
+
+protected:
+  virtual ADResidual computeQpResidual() override;
+
+  const ADMaterialProperty(Real) & _sb_constant;
+  const ADMaterialProperty(Real) & _absorptivity;
+  const Real _ff_temp;
+
+  usingIntegratedBCMembers;
+};
+
+#endif /* RADIATIONENERGYFLUXBC_H */
diff --git a/include/bcs/SurfaceTensionBC.h b/include/bcs/SurfaceTensionBC.h
new file mode 100644
index 00000000..8f414691
--- /dev/null
+++ b/include/bcs/SurfaceTensionBC.h
@@ -0,0 +1,37 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef SURFACETENSIONBC_H
+#define SURFACETENSIONBC_H
+
+#include "ADIntegratedBC.h"
+
+template <ComputeStage compute_stage>
+class SurfaceTensionBC;
+
+declareADValidParams(SurfaceTensionBC);
+
+template <ComputeStage compute_stage>
+class SurfaceTensionBC : public ADIntegratedBC<compute_stage>
+{
+public:
+  SurfaceTensionBC(const InputParameters & parameters);
+
+protected:
+  virtual ADResidual computeQpResidual() override;
+
+  usingIntegratedBCMembers;
+
+  const unsigned _component;
+  const ADMaterialProperty(RealVectorValue) & _surface_term_curvature;
+  const ADMaterialProperty(RealVectorValue) & _surface_term_gradient1;
+  const ADMaterialProperty(RealVectorValue) & _surface_term_gradient2;
+};
+
+#endif /* SURFACETENSIONBC_H */
diff --git a/include/bcs/VaporRecoilPressureMomentumFluxBC.h b/include/bcs/VaporRecoilPressureMomentumFluxBC.h
new file mode 100644
index 00000000..d0bd44fb
--- /dev/null
+++ b/include/bcs/VaporRecoilPressureMomentumFluxBC.h
@@ -0,0 +1,35 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#ifndef VAPORRECOILPRESSUREMOMENTUMFLUXBC_H
+#define VAPORRECOILPRESSUREMOMENTUMFLUXBC_H
+
+#include "ADIntegratedBC.h"
+
+template <ComputeStage compute_stage>
+class VaporRecoilPressureMomentumFluxBC;
+
+declareADValidParams(VaporRecoilPressureMomentumFluxBC);
+
+template <ComputeStage compute_stage>
+class VaporRecoilPressureMomentumFluxBC : public ADIntegratedBC<compute_stage>
+{
+public:
+  VaporRecoilPressureMomentumFluxBC(const InputParameters & parameters);
+
+protected:
+  virtual ADResidual computeQpResidual() override;
+
+  usingIntegratedBCMembers;
+
+  const unsigned _component;
+  const ADMaterialProperty(Real) & _rc_pressure;
+};
+
+#endif /* VAPORRECOILPRESSUREMOMENTUMFLUXBC_H */
diff --git a/include/kernels/ADStressDivergence.h b/include/kernels/ADStressDivergence.h
new file mode 100644
index 00000000..c0481dfb
--- /dev/null
+++ b/include/kernels/ADStressDivergence.h
@@ -0,0 +1,35 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+#ifndef ADSTRESSDIVERGENCE_H
+#define ADSTRESSDIVERGENCE_H
+
+#include "ADKernel.h"
+#include "MaterialProperty.h"
+
+// Forward Declaration
+template <ComputeStage compute_stage>
+class ADStressDivergence;
+
+declareADValidParams(ADStressDivergence);
+
+template <ComputeStage compute_stage>
+class ADStressDivergence : public ADKernel<compute_stage>
+{
+public:
+  ADStressDivergence(const InputParameters & parameters);
+
+protected:
+  virtual ADResidual computeQpResidual();
+
+  ADMaterialProperty(RealVectorValue) const * _stress;
+
+  usingKernelMembers;
+};
+
+#endif // ADSTRESSDIVERGENCE_H
diff --git a/include/materials/PseudoSolidStress.h b/include/materials/PseudoSolidStress.h
new file mode 100644
index 00000000..80624f6f
--- /dev/null
+++ b/include/materials/PseudoSolidStress.h
@@ -0,0 +1,41 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+#ifndef PSEUDOSOLIDSTRESS_H
+#define PSEUDOSOLIDSTRESS_H
+
+#include "ADMaterial.h"
+
+template <ComputeStage>
+class PseudoSolidStress;
+
+declareADValidParams(PseudoSolidStress);
+
+/**
+ * A material that couples a material property
+ */
+template <ComputeStage compute_stage>
+class PseudoSolidStress : public ADMaterial<compute_stage>
+{
+public:
+  PseudoSolidStress(const InputParameters & parameters);
+
+protected:
+  virtual void computeQpProperties();
+
+  ADMaterialProperty(RealVectorValue) & _stress_x;
+  ADMaterialProperty(RealVectorValue) & _stress_y;
+  ADMaterialProperty(RealVectorValue) & _stress_z;
+  const ADVariableGradient & _grad_disp_x;
+  const ADVariableGradient & _grad_disp_y;
+  const ADVariableGradient & _grad_disp_z;
+
+  usingMaterialMembers;
+};
+
+#endif // PSEUDOSOLIDSTRESS_H
diff --git a/src/bcs/DisplaceBoundaryBC.C b/src/bcs/DisplaceBoundaryBC.C
new file mode 100644
index 00000000..3d02ded8
--- /dev/null
+++ b/src/bcs/DisplaceBoundaryBC.C
@@ -0,0 +1,32 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "DisplaceBoundaryBC.h"
+
+registerADMooseObject("LaserWeldingApp", DisplaceBoundaryBC);
+
+defineADValidParams(DisplaceBoundaryBC,
+                    ADNodalBC,
+                    params.addClassDescription("For displacing a boundary");
+                    params.addRequiredCoupledVar("velocity", "The velocity at which to displace"););
+
+template <ComputeStage compute_stage>
+DisplaceBoundaryBC<compute_stage>::DisplaceBoundaryBC(const InputParameters & parameters)
+  : ADNodalBC<compute_stage>(parameters),
+    _velocity(adCoupledNodalValue("velocity")),
+    _u_old(_var.nodalValueOld())
+{
+}
+
+template <ComputeStage compute_stage>
+typename Moose::RealType<compute_stage>::type
+DisplaceBoundaryBC<compute_stage>::computeQpResidual()
+{
+  return _u - (_u_old + this->_dt * _velocity);
+}
diff --git a/src/bcs/GaussianWeldEnergyFluxBC.C b/src/bcs/GaussianWeldEnergyFluxBC.C
new file mode 100644
index 00000000..66b1b440
--- /dev/null
+++ b/src/bcs/GaussianWeldEnergyFluxBC.C
@@ -0,0 +1,50 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "GaussianWeldEnergyFluxBC.h"
+#include "Function.h"
+
+registerADMooseObject("LaserWeldingApp", GaussianWeldEnergyFluxBC);
+
+defineADValidParams(
+    GaussianWeldEnergyFluxBC,
+    ADIntegratedBC,
+    params.addRequiredParam<Real>("reff",
+                                  "The effective radius describing the radial distribution of the "
+                                  "beam energy. This should be non-dimensional.");
+    params.addRequiredParam<Real>("F0", "The average heat flux of the laser");
+    params.addRequiredParam<Real>("R", "The beam radius");
+    params.addParam<FunctionName>("x_beam_coord", 0, "The x coordinate of the center of the beam");
+    params.addParam<FunctionName>("y_beam_coord", 0, "The y coordinate of the center of the beam");
+    params.addParam<FunctionName>("z_beam_coord",
+                                  0,
+                                  "The z coordinate of the center of the beam"););
+
+template <ComputeStage compute_stage>
+GaussianWeldEnergyFluxBC<compute_stage>::GaussianWeldEnergyFluxBC(const InputParameters & params)
+  : ADIntegratedBC<compute_stage>(params),
+    _reff(adGetParam<Real>("reff")),
+    _F0(adGetParam<Real>("F0")),
+    _R(adGetParam<Real>("R")),
+    _x_beam_coord(getFunction("x_beam_coord")),
+    _y_beam_coord(getFunction("y_beam_coord")),
+    _z_beam_coord(getFunction("z_beam_coord"))
+{
+}
+
+template <ComputeStage compute_stage>
+ADResidual
+GaussianWeldEnergyFluxBC<compute_stage>::computeQpResidual()
+{
+  RealVectorValue beam_coords{_x_beam_coord.value(_t, _q_point[_qp]),
+                              _y_beam_coord.value(_t, _q_point[_qp]),
+                              _z_beam_coord.value(_t, _q_point[_qp])};
+  auto r = (_ad_q_points[_qp] - beam_coords).norm();
+  return -_test[_i][_qp] * 2. * _reff * _F0 * std::exp(-_reff * r * r / (_R * _R));
+}
diff --git a/src/bcs/PenaltyDisplaceBoundaryBC.C b/src/bcs/PenaltyDisplaceBoundaryBC.C
new file mode 100644
index 00000000..a66176c7
--- /dev/null
+++ b/src/bcs/PenaltyDisplaceBoundaryBC.C
@@ -0,0 +1,48 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "PenaltyDisplaceBoundaryBC.h"
+
+registerADMooseObject("LaserWeldingApp", PenaltyDisplaceBoundaryBC);
+
+defineADValidParams(PenaltyDisplaceBoundaryBC,
+                    ADIntegratedBC,
+                    params.addClassDescription("For displacing a boundary");
+                    params.addRequiredCoupledVar("disp_x", "The x displacement");
+                    params.addRequiredCoupledVar("vel_x", "The x velocity");
+                    params.addCoupledVar("disp_y", "The y displacement");
+                    params.addCoupledVar("vel_y", "The y velocity");
+                    params.addCoupledVar("disp_z", "The z displacement");
+                    params.addCoupledVar("vel_z", "The z velocity");
+                    params.addParam<Real>("penalty", 1e6, "The penalty coefficient"););
+
+template <ComputeStage compute_stage>
+PenaltyDisplaceBoundaryBC<compute_stage>::PenaltyDisplaceBoundaryBC(
+    const InputParameters & parameters)
+  : ADIntegratedBC<compute_stage>(parameters),
+    _vel_x(adCoupledValue("vel_x")),
+    _vel_y(this->isCoupled("vel_y") ? adCoupledValue("vel_y") : adZeroValue()),
+    _vel_z(this->isCoupled("vel_z") ? adCoupledValue("vel_") : adZeroValue()),
+    _disp_x_dot(adCoupledDot("disp_x")),
+    _disp_y_dot(this->isCoupled("disp_y") ? adCoupledDot("disp_y") : adZeroValue()),
+    _disp_z_dot(this->isCoupled("disp_z") ? adCoupledDot("disp_z") : adZeroValue()),
+    _penalty(adGetParam<Real>("penalty"))
+{
+}
+
+template <ComputeStage compute_stage>
+typename Moose::RealType<compute_stage>::type
+PenaltyDisplaceBoundaryBC<compute_stage>::computeQpResidual()
+{
+  return _test[_i][_qp] * _penalty * _normals[_qp] *
+         typename Moose::ValueType<compute_stage, VectorValue<Real>>::type(
+             _vel_x[_qp] - _disp_x_dot[_qp],
+             _vel_y[_qp] - _disp_y_dot[_qp],
+             _vel_z[_qp] - _disp_z_dot[_qp]);
+}
diff --git a/src/bcs/RadiationEnergyFluxBC.C b/src/bcs/RadiationEnergyFluxBC.C
new file mode 100644
index 00000000..c8ae26b3
--- /dev/null
+++ b/src/bcs/RadiationEnergyFluxBC.C
@@ -0,0 +1,43 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "RadiationEnergyFluxBC.h"
+
+registerADMooseObject("LaserWeldingApp", RadiationEnergyFluxBC);
+
+defineADValidParams(RadiationEnergyFluxBC,
+                    ADIntegratedBC,
+                    params.addClassDescription("Computes heat flux due to radiation");
+                    params.addParam<MaterialPropertyName>("sb_constant",
+                                                          "sb_constant",
+                                                          "The stefan-boltzmann constant");
+                    params.addParam<MaterialPropertyName>("absorptivity",
+                                                          "abs",
+                                                          "The absorptivity of the material");
+                    params.addRequiredParam<Real>("ff_temp", "The far field temperature"););
+
+template <ComputeStage compute_stage>
+RadiationEnergyFluxBC<compute_stage>::RadiationEnergyFluxBC(const InputParameters & parameters)
+  : ADIntegratedBC<compute_stage>(parameters),
+    _sb_constant(adGetADMaterialProperty<Real>("sb_constant")),
+    _absorptivity(adGetADMaterialProperty<Real>("absorptivity")),
+    _ff_temp(adGetParam<Real>("ff_temp"))
+{
+}
+
+template <ComputeStage compute_stage>
+ADResidual
+RadiationEnergyFluxBC<compute_stage>::computeQpResidual()
+{
+  auto u2 = _u[_qp] * _u[_qp];
+  auto u4 = u2 * u2;
+  auto ff2 = _ff_temp * _ff_temp;
+  auto ff4 = ff2 * ff2;
+  return _test[_i][_qp] * _absorptivity[_qp] * _sb_constant[_qp] * (u4 - ff4);
+}
diff --git a/src/bcs/SurfaceTensionBC.C b/src/bcs/SurfaceTensionBC.C
new file mode 100644
index 00000000..10de5afa
--- /dev/null
+++ b/src/bcs/SurfaceTensionBC.C
@@ -0,0 +1,37 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "SurfaceTensionBC.h"
+#include "Assembly.h"
+
+registerADMooseObject("LaserWeldingApp", SurfaceTensionBC);
+
+defineADValidParams(
+    SurfaceTensionBC, ADIntegratedBC, params.addClassDescription("Surface tension stresses.");
+    params.addRequiredParam<unsigned>("component", "The velocity component");
+    params.addCoupledVar("temperature", "The temperature for dependence of surface tension"););
+
+template <ComputeStage compute_stage>
+SurfaceTensionBC<compute_stage>::SurfaceTensionBC(const InputParameters & parameters)
+  : ADIntegratedBC<compute_stage>(parameters),
+    _component(adGetParam<unsigned>("component")),
+    _surface_term_curvature(adGetADMaterialProperty<RealVectorValue>("surface_term_curvature")),
+    _surface_term_gradient1(adGetADMaterialProperty<RealVectorValue>("surface_term_gradient1")),
+    _surface_term_gradient2(adGetADMaterialProperty<RealVectorValue>("surface_term_gradient2"))
+{
+}
+
+template <ComputeStage compute_stage>
+ADResidual
+SurfaceTensionBC<compute_stage>::computeQpResidual()
+{
+  return _test[_i][_qp] *
+         (_surface_term_curvature[_qp](_component) + _surface_term_gradient1[_qp](_component) +
+          _surface_term_gradient2[_qp](_component));
+}
diff --git a/src/bcs/VaporRecoilPressureMomentumFluxBC.C b/src/bcs/VaporRecoilPressureMomentumFluxBC.C
new file mode 100644
index 00000000..ed0793a9
--- /dev/null
+++ b/src/bcs/VaporRecoilPressureMomentumFluxBC.C
@@ -0,0 +1,36 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "VaporRecoilPressureMomentumFluxBC.h"
+
+registerADMooseObject("LaserWeldingApp", VaporRecoilPressureMomentumFluxBC);
+
+defineADValidParams(
+    VaporRecoilPressureMomentumFluxBC,
+    ADIntegratedBC,
+    params.addClassDescription("Vapor recoil pressure momentum flux");
+    params.addRequiredParam<unsigned>("component", "The velocity component");
+    params.addParam<MaterialPropertyName>("rc_pressure_name", "rc_pressure", "The recoil pressure");
+    params.addCoupledVar("temperature", "The temperature on which the recoil pressure depends"););
+
+template <ComputeStage compute_stage>
+VaporRecoilPressureMomentumFluxBC<compute_stage>::VaporRecoilPressureMomentumFluxBC(
+    const InputParameters & parameters)
+  : ADIntegratedBC<compute_stage>(parameters),
+    _component(adGetParam<unsigned>("component")),
+    _rc_pressure(adGetADMaterialProperty<Real>("rc_pressure_name"))
+{
+}
+
+template <ComputeStage compute_stage>
+ADResidual
+VaporRecoilPressureMomentumFluxBC<compute_stage>::computeQpResidual()
+{
+  return _test[_i][_qp] * std::abs(_normals[_qp](_component)) * _rc_pressure[_qp];
+}
diff --git a/src/kernels/ADStressDivergence.C b/src/kernels/ADStressDivergence.C
new file mode 100644
index 00000000..7fd62b23
--- /dev/null
+++ b/src/kernels/ADStressDivergence.C
@@ -0,0 +1,37 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+#include "ADStressDivergence.h"
+
+registerADMooseObject("LaserWeldingApp", ADStressDivergence);
+
+defineADValidParams(ADStressDivergence,
+                    ADKernel,
+                    params.addRequiredParam<int>("component", "The displacement component"););
+
+template <ComputeStage compute_stage>
+ADStressDivergence<compute_stage>::ADStressDivergence(const InputParameters & parameters)
+  : ADKernel<compute_stage>(parameters)
+{
+  const auto component = adGetParam<int>("component");
+  if (component == 0)
+    _stress = &adGetADMaterialProperty<RealVectorValue>("stress_x");
+  else if (component == 1)
+    _stress = &adGetADMaterialProperty<RealVectorValue>("stress_y");
+  else if (component == 2)
+    _stress = &adGetADMaterialProperty<RealVectorValue>("stress_z");
+  else
+    mooseError("component must be either 0, 1, or 2");
+}
+
+template <ComputeStage compute_stage>
+ADResidual
+ADStressDivergence<compute_stage>::computeQpResidual()
+{
+  return _grad_test[_i][_qp] * (*_stress)[_qp];
+}
diff --git a/src/materials/PseudoSolidStress.C b/src/materials/PseudoSolidStress.C
new file mode 100644
index 00000000..21c6eeef
--- /dev/null
+++ b/src/materials/PseudoSolidStress.C
@@ -0,0 +1,48 @@
+//* This file is part of the MOOSE framework
+//* https://www.mooseframework.org
+//*
+//* 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
+
+#include "PseudoSolidStress.h"
+
+registerADMooseObject("LaserWeldingApp", PseudoSolidStress);
+
+defineADValidParams(PseudoSolidStress,
+                    ADMaterial,
+                    params.addRequiredCoupledVar("disp_x", "The x displacement");
+                    params.addCoupledVar("disp_y", "The y displacement");
+                    params.addCoupledVar("disp_z", "The z displacement"););
+
+template <ComputeStage compute_stage>
+PseudoSolidStress<compute_stage>::PseudoSolidStress(const InputParameters & parameters)
+  : ADMaterial<compute_stage>(parameters),
+    _stress_x(adDeclareADProperty<RealVectorValue>("stress_x")),
+    _stress_y(adDeclareADProperty<RealVectorValue>("stress_y")),
+    _stress_z(adDeclareADProperty<RealVectorValue>("stress_z")),
+    _grad_disp_x(adCoupledGradient("disp_x")),
+    _grad_disp_y(this->isCoupled("disp_y") ? adCoupledGradient("disp_y") : adZeroGradient()),
+    _grad_disp_z(this->isCoupled("disp_z") ? adCoupledGradient("disp_z") : adZeroGradient())
+{
+}
+
+template <ComputeStage compute_stage>
+void
+PseudoSolidStress<compute_stage>::computeQpProperties()
+{
+  typedef typename Moose::template ValueType<compute_stage, TensorValue<Real>>::type LocalTensor;
+  LocalTensor def_gradient(_grad_disp_x[_qp], _grad_disp_y[_qp], _grad_disp_z[_qp]);
+  const auto E =
+      0.5 * (def_gradient + def_gradient.transpose() - def_gradient * def_gradient.transpose());
+  TensorValue<Real> identity(1., 0, 0, 0, 1., 0, 0, 0, 1.);
+  const auto S = 2. * E + E.tr() * identity;
+  _stress_x[_qp] = S.row(0);
+  _stress_y[_qp] = S.row(1);
+  _stress_z[_qp] = S.row(2);
+  // _stress_x[_qp] = def_gradient.row(0);
+  // _stress_y[_qp] = def_gradient.row(1);
+  // _stress_z[_qp] = def_gradient.row(2);
+}