Calculates the radial displacement for spherical geometries. More...

#include <RadialDisplacementSphereAux.h>

Inheritance diagram for RadialDisplacementSphereAux:

Public Member Functions
	RadialDisplacementSphereAux (const InputParameters &parameters)

virtual	~RadialDisplacementSphereAux ()

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual Real	computeValue ()
	Compute the value of the radial displacement. More...

Protected Attributes
Moose::CoordinateSystemType	_coord_system
	Type of coordinate system. More...

unsigned int	_ndisp
	Number of displacment components. More...

std::vector< const VariableValue * >	_disp_vals
	Coupled variable values of the displacement components. More...

RealVectorValue	_origin
	Point used to define an origin for 2D axisymmetric or 3D Cartesian systems. More...

Detailed Description

Calculates the radial displacement for spherical geometries.

Works for 3D, 2D axisymmetric, and 1D geometries

Definition at line 24 of file RadialDisplacementSphereAux.h.

Constructor & Destructor Documentation

◆ RadialDisplacementSphereAux()

RadialDisplacementSphereAux::RadialDisplacementSphereAux ( const InputParameters & parameters )

Definition at line 33 of file RadialDisplacementSphereAux.C.

   : AuxKernel(parameters), _ndisp(coupledComponents("displacements")), _disp_vals(_ndisp)
 {
   const std::set<SubdomainID> & subdomains = _mesh.meshSubdomains();
   const auto & sbd_begin = *subdomains.begin();
   for (const auto & sbd : subdomains)
   {
     if (sbd == sbd_begin)
       _coord_system = _subproblem.getCoordSystem(sbd);
     else if (_subproblem.getCoordSystem(sbd) != _coord_system)
       mooseError(
           "RadialDisplacementSphereAux requires that all subdomains have the same coordinate type");
   }
  
   for (unsigned int i = 0; i < _ndisp; ++i)
     _disp_vals[i] = &coupledValue("displacements", i);
  
   if (_ndisp != _mesh.dimension())
     mooseError("The number of displacement variables supplied must match the mesh dimension.");
  
   if ((_coord_system == Moose::COORD_XYZ) || (_coord_system == Moose::COORD_RZ))
   {
     if (isParamValid("origin"))
       _origin = getParam<RealVectorValue>("origin");
     else
       mooseError(
           "Must specify 'origin' for models with Cartesian or axisymmetric coordinate systems.");
   }
   else if (isParamValid("origin"))
     mooseError("The 'origin' parameter is only valid for models with Cartesian or axisymmetric "
                "coordinate systems.");
  
   if (_coord_system == Moose::COORD_XYZ && _ndisp != 3)
     mooseError("Cannot compute radial displacement for models with 1D or 2D Cartesian system");
  
   if (_coord_system == Moose::COORD_RZ && _ndisp != 2)
     mooseError(
         "Can only compute radial displacement for axisymmetric systems if the dimensionality is 2");
  
   if (!isNodal())
     mooseError("Must run on a nodal variable");
 }

◆ ~RadialDisplacementSphereAux()

virtual RadialDisplacementSphereAux::~RadialDisplacementSphereAux ( )

inlinevirtual

Definition at line 31 of file RadialDisplacementSphereAux.h.

31 {}

Member Function Documentation

◆ computeValue()

Real RadialDisplacementSphereAux::computeValue ( )

protectedvirtual

Compute the value of the radial displacement.

Definition at line 77 of file RadialDisplacementSphereAux.C.

 {
   Real rad_disp = 0.0;
  
   if ((_coord_system == Moose::COORD_XYZ && _ndisp == 3) ||
       (_coord_system == Moose::COORD_RZ && _ndisp == 2))
   {
     Point current_point(*_current_node);
     RealVectorValue rad_vec(current_point - _origin);
     Real rad = rad_vec.norm();
     const RealVectorValue disp_vec(
         (*_disp_vals[0])[_qp], (*_disp_vals[1])[_qp], (_ndisp == 3 ? (*_disp_vals[2])[_qp] : 0.0));
     if (rad > 0.0)
     {
       rad_vec /= rad;
       rad_disp = rad_vec * disp_vec;
     }
     else
       rad_disp = disp_vec.norm();
   }
   else if (_coord_system == Moose::COORD_RSPHERICAL)
     rad_disp = (*_disp_vals[0])[_qp];
   else
     mooseError("Unsupported coordinate system");
  
   return rad_disp;
 }

◆ validParams()

InputParameters RadialDisplacementSphereAux::validParams ( )

static

Definition at line 18 of file RadialDisplacementSphereAux.C.

 {
   InputParameters params = AuxKernel::validParams();
   params.addClassDescription(
       "Compute the radial component of the displacement vector for spherical models.");
   params.addRequiredCoupledVar(
       "displacements",
       "The displacements appropriate for the simulation geometry and coordinate system");
   params.addParam<RealVectorValue>("origin",
                                    "Sphere origin for 3D Cartesian and 2D axisymmetric models");
   params.set<bool>("use_displaced_mesh") = false;
  
   return params;
 }