NearestPointBase< UserObjectType, BaseType > Class Template Reference

This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z). More...

#include <NearestPointBase.h>

Inheritance diagram for NearestPointBase< UserObjectType, BaseType >:

Public Member Functions
	NearestPointBase (const InputParameters &parameters)
	~NearestPointBase ()
virtual void	initialize () override
virtual void	execute () override
virtual void	finalize () override
virtual void	threadJoin (const UserObject &y) override
virtual Real	spatialValue (const Point &p) const override
	Given a Point return the integral value associated with the layer that point falls in for the layered average closest to that point. More...
virtual const std::vector< Point > &	getPoints () const
	Get the points at which the nearest operation is performed. More...
virtual const std::vector< Point >	spatialPoints () const override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	fillPoints ()
	Fills in the _points variable from either 'points' or 'points_file' parameter. More...
UserObjectType &	nearestUserObject (const Point &p) const
	Get the UserObject that is closest to the point. More...
virtual const std::string &	name () const
	Get the name of the class. More...

Protected Attributes
std::vector< Point >	_points
std::vector< std::unique_ptr< UserObjectType > >	_user_objects
const unsigned int	_dist_norm
const unsigned int	_axis

Detailed Description

template<typename UserObjectType, typename BaseType>
class NearestPointBase< UserObjectType, BaseType >

This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).

Given a list of points this object computes the layered average closest to each one of those points.

Definition at line 29 of file NearestPointBase.h.

Constructor & Destructor Documentation

NearestPointBase()

template<typename UserObjectType , typename BaseType >

NearestPointBase< UserObjectType, BaseType >::NearestPointBase

(

const InputParameters &

parameters

)

Definition at line 117 of file NearestPointBase.h.

  : BaseType(parameters),
    _dist_norm(this->template getParam<MooseEnum>("dist_norm")),
    _axis(this->template getParam<MooseEnum>("axis"))
{
  if (this->template getParam<MooseEnum>("dist_norm") != "radius" &&
      parameters.isParamSetByUser("axis"))
    this->template paramError("axis",
                              "'axis' should only be set if 'dist_norm' is set to 'radius'");

  fillPoints();

  _user_objects.resize(_points.size());

  // Build each of the UserObject objects that we will manage manually
  // If you're looking at this in the future and want to replace this behavior,
  // _please_ don't do it. MOOSE should manage these objects.
  for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
  {
    const auto uo_type = MooseUtils::prettyCppType<UserObjectType>();
    auto sub_params = this->_app.getFactory().getValidParams(uo_type);
    sub_params.applyParameters(parameters, {}, true);

    const auto sub_name = name() + "_sub" + std::to_string(i);
    auto uo = this->_app.getFactory().template createUnique<UserObjectType>(
        uo_type, sub_name, sub_params, this->_tid);
    _user_objects[i] = std::move(uo);
  }
}

~NearestPointBase()

template<typename UserObjectType , typename BaseType >

NearestPointBase< UserObjectType, BaseType >::~NearestPointBase

(

)

Definition at line 148 of file NearestPointBase.h.

{
}

Member Function Documentation

execute()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::execute ( )

overridevirtual

Definition at line 186 of file NearestPointBase.h.

{
  nearestUserObject(_current_elem->vertex_average()).execute();
}

fillPoints()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::fillPoints ( )

protected

Fills in the _points variable from either 'points' or 'points_file' parameter.

Also performs error checking.

Definition at line 154 of file NearestPointBase.h.

Referenced by NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::NearestPointBase().

{
  if (isParamValid("points") && isParamValid("points_file"))
    mooseError(name(), ": Both 'points' and 'points_file' cannot be specified simultaneously.");

  if (isParamValid("points"))
  {
    _points = this->template getParam<std::vector<Point>>("points");
  }
  else if (isParamValid("points_file"))
  {
    const FileName & points_file = this->template getParam<FileName>("points_file");

    MooseUtils::DelimitedFileReader file(points_file, &_communicator);
    file.setFormatFlag(MooseUtils::DelimitedFileReader::FormatFlag::ROWS);
    file.read();
    _points = file.getDataAsPoints();
  }
  else
    mooseError(name(), ": You need to supply either 'points' or 'points_file' parameter.");
}

finalize()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::finalize ( )

overridevirtual

Reimplemented in NearestPointAverage, and NearestPointIntegralVariablePostprocessor.

Definition at line 193 of file NearestPointBase.h.

{
  for (auto & user_object : _user_objects)
    user_object->finalize();
}

getPoints()

template<typename UserObjectType, typename BaseType>

virtual const std::vector<Point>& NearestPointBase< UserObjectType, BaseType >::getPoints ( ) const

inlinevirtual

Get the points at which the nearest operation is performed.

Returns

points

Definition at line 55 of file NearestPointBase.h.

{ return _points; }

initialize()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::initialize ( )

overridevirtual

Definition at line 178 of file NearestPointBase.h.

{
  for (auto & user_object : _user_objects)
    user_object->initialize();
}

name()

template<typename UserObjectType, typename BaseType>

virtual const std::string& MooseBase::name

inlineprotected

Get the name of the class.

Returns

The name of the class

Definition at line 57 of file MooseBase.h.

{ return _name; }

nearestUserObject()

template<typename UserObjectType , typename BaseType >

UserObjectType & NearestPointBase< UserObjectType, BaseType >::nearestUserObject ( const Point &  p ) const

protected

Get the UserObject that is closest to the point.

Parameters

p	The point.

Returns

The UserObject closest to p.

Definition at line 218 of file NearestPointBase.h.

{
  unsigned int closest = 0;
  Real closest_distance = std::numeric_limits<Real>::max();

  for (auto it : Moose::enumerate(_points))
  {
    const auto & current_point = it.value();

    Real current_distance;
    if (_dist_norm == 0)
      // the distance is computed using standard norm
      current_distance = (p - current_point).norm();
    else
    {
      // the distance is to be computed based on radii
      // in that case, we need to determine the 2 coordinate indices
      // that define the radius
      unsigned int i = 0;
      unsigned int j = 1;

      if (_axis == 0)
        i = 2;
      else if (_axis == 1)
        j = 2;

      current_distance = std::abs(
          std::sqrt(p(i) * p(i) + p(j) * p(j)) -
          std::sqrt(current_point(i) * current_point(i) + current_point(j) * current_point(j)));
    }

    if (current_distance < closest_distance)
    {
      closest_distance = current_distance;
      closest = it.index();
    }
  }

  return *_user_objects[closest];
}

spatialPoints()

template<typename UserObjectType , typename BaseType >

const std::vector< Point > NearestPointBase< UserObjectType, BaseType >::spatialPoints ( ) const

overridevirtual

Reimplemented in NearestPointIntegralVariablePostprocessor.

Definition at line 261 of file NearestPointBase.h.

{
  std::vector<Point> points;

  for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
  {
    auto layered_base = dynamic_cast<LayeredBase *>(_user_objects[i].get());
    if (layered_base)
    {
      const auto & layers = layered_base->getLayerCenters();
      auto direction = layered_base->direction();

      for (const auto & l : layers)
      {
        Point pt = _points[i];
        pt(direction) = l;
        points.push_back(pt);
      }
    }
  }

  return points;
}

spatialValue()

template<typename UserObjectType , typename BaseType >

Real NearestPointBase< UserObjectType, BaseType >::spatialValue ( const Point &  p ) const

overridevirtual

Given a Point return the integral value associated with the layer that point falls in for the layered average closest to that point.

Parameters

p	The point to look for in the layers.

Reimplemented in NearestPointAverage, and NearestPointIntegralVariablePostprocessor.

Definition at line 211 of file NearestPointBase.h.

{
  return nearestUserObject(p).spatialValue(p);
}

threadJoin()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::threadJoin ( const UserObject &  y )

overridevirtual

Definition at line 201 of file NearestPointBase.h.

{
  auto & npla = static_cast<const NearestPointBase &>(y);

  for (MooseIndex(_user_objects) i = 0; i < _user_objects.size(); ++i)
    _user_objects[i]->threadJoin(*npla._user_objects[i]);
}

validParams()

template<typename UserObjectType , typename BaseType >

InputParameters NearestPointBase< UserObjectType, BaseType >::validParams ( )

static

Definition at line 91 of file NearestPointBase.h.

Referenced by NearestPointLayeredSideAverageFunctor::validParams(), NearestPointLayeredSideIntegralFunctor::validParams(), NearestPointAverage::validParams(), NearestPointLayeredSideIntegral::validParams(), NearestPointLayeredAverage::validParams(), NearestPointLayeredSideAverage::validParams(), NearestPointLayeredIntegral::validParams(), and NearestRadiusLayeredAverage::validParams().

{
  InputParameters params = BaseType::validParams();

  params.addParam<std::vector<Point>>("points",
                                      "Computations will be lumped into values at these points.");
  params.addParam<FileName>("points_file",
                            "A filename that should be looked in for points. Each "
                            "set of 3 values in that file will represent a Point. "
                            "This and 'points' cannot be both supplied.");

  MooseEnum distnorm("point=0 radius=1", "point");
  params.addParam<MooseEnum>(
      "dist_norm", distnorm, "To specify whether the distance is defined based on point or radius");
  MooseEnum axis("x=0 y=1 z=2", "z");
  params.addParam<MooseEnum>("axis", axis, "The axis around which the radius is determined");

  params.addParamNamesToGroup("points points_file dist_norm axis", "Points and distance to points");

  // Add in the valid parameters
  params += UserObjectType::validParams();

  return params;
}

Member Data Documentation

_axis

template<typename UserObjectType, typename BaseType>

const unsigned int NearestPointBase< UserObjectType, BaseType >::_axis

protected

Definition at line 80 of file NearestPointBase.h.

_dist_norm

template<typename UserObjectType, typename BaseType>

const unsigned int NearestPointBase< UserObjectType, BaseType >::_dist_norm

protected

Definition at line 78 of file NearestPointBase.h.

_points

template<typename UserObjectType, typename BaseType>

std::vector<Point> NearestPointBase< UserObjectType, BaseType >::_points

protected

Definition at line 74 of file NearestPointBase.h.

Referenced by NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::getPoints(), and NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::NearestPointBase().

_user_objects

template<typename UserObjectType, typename BaseType>

std::vector<std::unique_ptr<UserObjectType> > NearestPointBase< UserObjectType, BaseType >::_user_objects

protected

Definition at line 75 of file NearestPointBase.h.

Referenced by NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::NearestPointBase().

---

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

• include/userobjects/NearestPointBase.h