NodalGravity Class Reference

Calculates the gravitational force proportional to nodal mass. More...

#include <NodalGravity.h>

Inheritance diagram for NodalGravity:

Public Member Functions
	NodalGravity (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual Real	computeQpResidual () override

Protected Attributes
const bool	_has_mass
	Booleans for validity of params. More...
const bool	_has_nodal_mass_file
const Real	_mass
	Mass associated with the node. More...
const Real	_alpha
	HHT time integration parameter. More...
const Real	_gravity_value
	Acceleration due to gravity. More...
const Function &	_function
	Time and space dependent factor multiplying acceleration due to gravity. More...
std::map< dof_id_type, Real >	_node_id_to_mass
	Map between boundary nodes and nodal mass. More...

Detailed Description

Calculates the gravitational force proportional to nodal mass.

Definition at line 23 of file NodalGravity.h.

Constructor & Destructor Documentation

NodalGravity()

NodalGravity::NodalGravity

(

const InputParameters &

parameters

)

Definition at line 40 of file NodalGravity.C.

  : NodalKernel(parameters),
    _has_mass(isParamValid("mass")),
    _has_nodal_mass_file(isParamValid("nodal_mass_file")),
    _mass(_has_mass ? getParam<Real>("mass") : 0.0),
    _alpha(getParam<Real>("alpha")),
    _gravity_value(getParam<Real>("gravity_value")),
    _function(getFunction("function"))
{
  if (!_has_nodal_mass_file && !_has_mass)
    mooseError("NodalGravity: Please provide either mass or nodal_mass_file as input.");
  else if (_has_nodal_mass_file && _has_mass)
    mooseError("NodalGravity: Please provide either mass or nodal_mass_file as input, not both.");
 
  if (_has_nodal_mass_file)
  {
    MooseUtils::DelimitedFileReader nodal_mass_file(getParam<FileName>("nodal_mass_file"));
    nodal_mass_file.setHeaderFlag(MooseUtils::DelimitedFileReader::HeaderFlag::OFF);
    nodal_mass_file.read();
    std::vector<std::vector<Real>> data = nodal_mass_file.getData();
    if (data.size() != 4)
      mooseError("NodalGravity: The number of columns in ",
                 getParam<FileName>("nodal_mass_file"),
                 " should be 4.");
 
    unsigned int node_found = 0;
    const std::set<BoundaryID> bnd_ids = BoundaryRestrictable::boundaryIDs();
    for (auto & bnd_id : bnd_ids)
    {
      const std::vector<dof_id_type> & bnd_node_set = _mesh.getNodeList(bnd_id);
      for (auto & bnd_node : bnd_node_set)
      {
        const Node & node = _mesh.nodeRef(bnd_node);
        _node_id_to_mass[bnd_node] = 0.0;
 
        for (unsigned int i = 0; i < data[0].size(); ++i)
        {
          if (MooseUtils::absoluteFuzzyEqual(data[0][i], node(0), 1e-6) &&
              MooseUtils::absoluteFuzzyEqual(data[1][i], node(1), 1e-6) &&
              MooseUtils::absoluteFuzzyEqual(data[2][i], node(2), 1e-6))
          {
            _node_id_to_mass[bnd_node] = data[3][i];
            node_found += 1;
            break;
          }
        }
      }
    }
    if (node_found != data[0].size())
      mooseError("NodalGravity: Out of ",
                 data[0].size(),
                 " nodal positions in ",
                 getParam<FileName>("nodal_mass_file"),
                 " only ",
                 node_found,
                 " nodes were found in the boundary.");
  }
}

Member Function Documentation

computeQpResidual()

Real NodalGravity::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 100 of file NodalGravity.C.

{
  Real mass = 0.0;
  if (_has_mass)
    mass = _mass;
  else
  {
    if (_node_id_to_mass.find(_current_node->id()) != _node_id_to_mass.end())
      mass = _node_id_to_mass[_current_node->id()];
    else
      mooseError("NodalGravity: Unable to find an entry for the current node in the "
                 "_node_id_to_mass map.");
  }
  Real factor = _gravity_value * _function.value(_t + _alpha * _dt, (*_current_node));
  return mass * -factor;
}

validParams()

InputParameters NodalGravity::validParams ( )

static

Definition at line 20 of file NodalGravity.C.

{
  InputParameters params = NodalKernel::validParams();
  params.addClassDescription("Computes the gravitational force for a given nodal mass.");
  params.addRangeCheckedParam<Real>("alpha",
                                    0.0,
                                    "alpha >= -0.3333 & alpha <= 0.0",
                                    "Alpha parameter for mass dependent numerical damping induced "
                                    "by HHT time integration scheme");
  params.addParam<Real>("mass", "Mass associated with the node");
  params.addParam<FileName>(
      "nodal_mass_file",
      "The file containing the nodal positions and the corresponding nodal masses.");
  params.addParam<Real>("gravity_value", 0.0, "Acceleration due to gravity.");
  // A ConstantFunction of "1" is supplied as the default
  params.addParam<FunctionName>(
      "function", "1", "A function that describes the gravitational force");
  return params;
}

Member Data Documentation

_alpha

const Real NodalGravity::_alpha

protected

HHT time integration parameter.

Definition at line 41 of file NodalGravity.h.

Referenced by computeQpResidual().

_function

const Function& NodalGravity::_function

protected

Time and space dependent factor multiplying acceleration due to gravity.

Definition at line 47 of file NodalGravity.h.

Referenced by computeQpResidual().

_gravity_value

const Real NodalGravity::_gravity_value

protected

Acceleration due to gravity.

Definition at line 44 of file NodalGravity.h.

Referenced by computeQpResidual().

_has_mass

const bool NodalGravity::_has_mass

protected

Booleans for validity of params.

Definition at line 34 of file NodalGravity.h.

Referenced by computeQpResidual(), and NodalGravity().

_has_nodal_mass_file

const bool NodalGravity::_has_nodal_mass_file

protected

Definition at line 35 of file NodalGravity.h.

Referenced by NodalGravity().

_mass

const Real NodalGravity::_mass

protected

Mass associated with the node.

Definition at line 38 of file NodalGravity.h.

Referenced by computeQpResidual().

_node_id_to_mass

std::map<dof_id_type, Real> NodalGravity::_node_id_to_mass

protected

Map between boundary nodes and nodal mass.

Definition at line 50 of file NodalGravity.h.

Referenced by computeQpResidual(), and NodalGravity().

---

The documentation for this class was generated from the following files:

• tensor_mechanics/include/nodalkernels/NodalGravity.h
• tensor_mechanics/src/nodalkernels/NodalGravity.C