LayeredBase Class Reference

This UserObject (????? this isn't a userobject) computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z). More...

#include <LayeredBase.h>

Inheritance diagram for LayeredBase:

Public Member Functions
	LayeredBase (const InputParameters &parameters)
virtual Real	integralValue (Point p) const
	Given a Point return the integral value associated with the layer that point falls in. More...
virtual Real	getLayerValue (unsigned int layer) const
	Get the value for a given layer. More...
virtual unsigned int	getLayer (Point p) const
	Helper function to return the layer the point lies in. More...
virtual void	initialize ()
virtual void	finalize ()
virtual void	threadJoin (const UserObject &y)

Protected Member Functions
void	setLayerValue (unsigned int layer, Real value)
	Set the value for a particular layer. More...
bool	layerHasValue (unsigned int layer) const
	Whether or not a layer has a value. More...
void	getBounds ()
	Compute bounds, restricted to blocks if given. More...

Protected Attributes
std::string	_layered_base_name
	Name of this object. More...
const InputParameters &	_layered_base_params
	Params for this object. More...
MooseEnum	_direction_enum
	The MooseEnum direction the layers are going in. More...
unsigned int	_direction
	The component direction the layers are going in. We cache this for speed (so we're not always going through the MooseEnum) More...
bool	_interval_based
	Whether or not this object is based on equally spaced intervals or "bounds". More...
unsigned int	_num_layers
	Number of layers to split the mesh into. More...
std::vector< Real >	_layer_bounds
	The boundaries of the layers. More...
unsigned int	_sample_type
	How to sample the values. More...
unsigned int	_average_radius
	How many layers both above and below the found layer will be used in the average. More...
bool	_using_displaced_mesh
	true if this object operates on the displaced mesh, otherwise false More...
Real	_direction_min
Real	_direction_max

Private Member Functions
template<typename T >
T &	declareRestartableData (std::string data_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, const T &init_value, void *context)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRecoverableData (std::string data_name)
	Declare a piece of data as "recoverable". More...
template<typename T >
T &	declareRecoverableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithObjectName (std::string data_name, std::string object_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithObjectNameWithContext (std::string data_name, std::string object_name, void *context)
	Declare a piece of data as "restartable". More...

Private Attributes
std::vector< Real > &	_layer_values
	Value of the integral for each layer. More...
std::vector< int > &	_layer_has_value
	Whether or not each layer has had any value summed into it. More...
SubProblem &	_layered_base_subproblem
	Subproblem for the child object. More...
bool	_cumulative
	Whether the values are cumulative over the layers. More...
std::vector< SubdomainID >	_blocks
	List of SubdomainIDs, if given. More...

Detailed Description

This UserObject (????? this isn't a userobject) computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).

Definition at line 41 of file LayeredBase.h.

Constructor & Destructor Documentation

LayeredBase()

LayeredBase::LayeredBase

(

const InputParameters &

parameters

)

Definition at line 60 of file LayeredBase.C.

  : Restartable(parameters.getCheckedPointerParam<SubProblem *>("_subproblem")->getMooseApp(),
                parameters.get<std::string>("_object_name") + "_layered_base",
                "LayeredBase",
                parameters.get<THREAD_ID>("_tid")),
    _layered_base_name(parameters.get<std::string>("_object_name")),
    _layered_base_params(parameters),
    _direction_enum(parameters.get<MooseEnum>("direction")),
    _direction(_direction_enum),
    _sample_type(parameters.get<MooseEnum>("sample_type")),
    _average_radius(parameters.get<unsigned int>("average_radius")),
    _using_displaced_mesh(_layered_base_params.get<bool>("use_displaced_mesh")),
    _layer_values(declareRestartableData<std::vector<Real>>("layer_values")),
    _layer_has_value(declareRestartableData<std::vector<int>>("layer_has_value")),
    _layered_base_subproblem(*parameters.getCheckedPointerParam<SubProblem *>("_subproblem")),
    _cumulative(parameters.get<bool>("cumulative")),
    _blocks()
{
  if (_layered_base_params.isParamValid("num_layers") &&
      _layered_base_params.isParamValid("bounds"))
    mooseError("'bounds' and 'num_layers' cannot both be set in ", _layered_base_name);

  if (_layered_base_params.isParamValid("num_layers"))
  {
    _num_layers = _layered_base_params.get<unsigned int>("num_layers");
    _interval_based = true;
  }
  else if (_layered_base_params.isParamValid("bounds"))
  {
    _interval_based = false;

    _layer_bounds = _layered_base_params.get<std::vector<Real>>("bounds");

    // Make sure the bounds are sorted - we're going to depend on this
    std::sort(_layer_bounds.begin(), _layer_bounds.end());

    _num_layers = _layer_bounds.size() - 1; // Layers are only in-between the bounds
  }
  else
    mooseError("One of 'bounds' or 'num_layers' must be specified for ", _layered_base_name);

  if (!_interval_based && _sample_type == 1)
    mooseError("'sample_type = interpolate' not supported with 'bounds' in ", _layered_base_name);

  if (_layered_base_params.isParamValid("block"))
    _blocks = _layered_base_subproblem.mesh().getSubdomainIDs(
        _layered_base_params.get<std::vector<SubdomainName>>("block"));

  _layer_values.resize(_num_layers);
  _layer_has_value.resize(_num_layers);

  getBounds();
}

Member Function Documentation

declareRecoverableData() [1/2]

template<typename T >

T & Restartable::declareRecoverableData ( std::string  data_name )

protectedinherited

Declare a piece of data as "recoverable".

This means that in the event of a recovery this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 269 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;

  registerRecoverableDataOnApp(full_name);

  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRecoverableData() [2/2]

template<typename T >

T & Restartable::declareRecoverableData ( std::string  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 280 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;

  registerRecoverableDataOnApp(full_name);

  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableData() [1/2]

template<typename T >

T & Restartable::declareRestartableData ( std::string  data_name )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 202 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRestartableData() [2/2]

template<typename T >

T & Restartable::declareRestartableData ( std::string  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 209 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableDataWithContext() [1/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( std::string  data_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions

Definition at line 216 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  T & restartable_data_ref = data_ptr->get();

  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);

  return restartable_data_ref;
}

declareRestartableDataWithContext() [2/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( std::string  data_name, const T &  init_value, void *  context  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data
context	Context pointer that will be passed to the load and store functions

Definition at line 229 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  data_ptr->set() = init_value;

  T & restartable_data_ref = data_ptr->get();
  registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid);

  return restartable_data_ref;
}

declareRestartableDataWithObjectName()

template<typename T >

T & Restartable::declareRestartableDataWithObjectName ( std::string  data_name, std::string  object_name  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.

Definition at line 245 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(data_name, object_name, nullptr);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T >

T & Restartable::declareRestartableDataWithObjectNameWithContext ( std::string  data_name, std::string  object_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions

Definition at line 252 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context);

  _restartable_name = old_name;

  return value;
}

finalize()

void LayeredBase::finalize ( )

virtual

Reimplemented in LayeredSideIntegral, LayeredIntegral, LayeredSideAverage, and LayeredAverage.

Definition at line 249 of file LayeredBase.C.

Referenced by LayeredIntegral::finalize(), and LayeredSideIntegral::finalize().

{
  _layered_base_subproblem.comm().sum(_layer_values);
  _layered_base_subproblem.comm().max(_layer_has_value);

  if (_cumulative)
  {
    Real value = 0;

    for (unsigned i = 0; i < _num_layers; ++i)
    {
      value += getLayerValue(i);
      setLayerValue(i, value);
    }
  }
}

getBounds()

void LayeredBase::getBounds ( )

protected

Compute bounds, restricted to blocks if given.

Definition at line 323 of file LayeredBase.C.

Referenced by initialize(), and LayeredBase().

{
  if (_blocks.size() == 0)
  {
    BoundingBox bounding_box = MeshTools::create_bounding_box(_layered_base_subproblem.mesh());
    _direction_min = bounding_box.min()(_direction);
    _direction_max = bounding_box.max()(_direction);
  }
  else
  {
    _direction_min = std::numeric_limits<Real>::infinity();
    _direction_max = -std::numeric_limits<Real>::infinity();

    MooseMesh & mesh = _layered_base_subproblem.mesh();

    for (auto & elem_ptr : *mesh.getActiveLocalElementRange())
    {
      auto subdomain_id = elem_ptr->subdomain_id();

      if (std::find(_blocks.begin(), _blocks.end(), subdomain_id) == _blocks.end())
        continue;

      for (auto & node : elem_ptr->node_ref_range())
      {
        _direction_min = std::min(_direction_min, node(_direction));
        _direction_max = std::max(_direction_max, node(_direction));
      }
    }

    mesh.comm().min(_direction_min);
    mesh.comm().max(_direction_max);
  }
}

getLayer()

unsigned int LayeredBase::getLayer ( Point  p ) const

virtual

Helper function to return the layer the point lies in.

Parameters

p	The point.

Returns

The layer the Point is found in.

Definition at line 276 of file LayeredBase.C.

Referenced by LayeredAverage::execute(), LayeredSideAverage::execute(), LayeredIntegral::execute(), LayeredSideIntegral::execute(), and integralValue().

{
  Real direction_x = p(_direction);

  if (direction_x < _direction_min)
    return 0;

  if (_interval_based)
  {
    unsigned int layer =
        std::floor(((direction_x - _direction_min) / (_direction_max - _direction_min)) *
                   static_cast<Real>(_num_layers));

    if (layer >= _num_layers)
      layer = _num_layers - 1;

    return layer;
  }
  else // Figure out what layer we are in from the bounds
  {
    // This finds the first entry in the vector that is larger than what we're looking for
    std::vector<Real>::const_iterator one_higher =
        std::upper_bound(_layer_bounds.begin(), _layer_bounds.end(), direction_x);

    if (one_higher == _layer_bounds.end())
    {
      return static_cast<unsigned int>(
          _layer_bounds.size() -
          2); // Just return the last layer.  -2 because layers are "in-between" bounds
    }
    else if (one_higher == _layer_bounds.begin())
      return 0; // Return the first layer
    else
      // The -1 is because the interval that we fall in is just _before_ the number that is bigger
      // (which is what we found
      return static_cast<unsigned int>(std::distance(_layer_bounds.begin(), one_higher - 1));
  }
}

getLayerValue()

Real LayeredBase::getLayerValue ( unsigned int  layer ) const

virtual

Get the value for a given layer.

Parameters

layer

The layer index

Returns

The value for the given layer

Definition at line 226 of file LayeredBase.C.

Referenced by LayeredIntegral::execute(), LayeredSideIntegral::execute(), LayeredAverage::finalize(), LayeredSideAverage::finalize(), finalize(), and threadJoin().

{
  if (layer >= _layer_values.size())
    mooseError("Layer '", layer, "' not found in '", _layered_base_name, "'.");
  return _layer_values[layer];
}

initialize()

void LayeredBase::initialize ( )

virtual

Reimplemented in LayeredSideIntegral, LayeredIntegral, LayeredSideAverage, and LayeredAverage.

Definition at line 234 of file LayeredBase.C.

Referenced by LayeredIntegral::initialize(), and LayeredSideIntegral::initialize().

{
  if (_using_displaced_mesh)
  {
    getBounds();
  }

  for (unsigned int i = 0; i < _layer_values.size(); i++)
  {
    _layer_values[i] = 0.0;
    _layer_has_value[i] = false;
  }
}

integralValue()

Real LayeredBase::integralValue ( Point  p ) const

virtual

Given a Point return the integral value associated with the layer that point falls in.

Parameters

p	The point to look for in the layers.

Definition at line 115 of file LayeredBase.C.

Referenced by LayeredIntegral::spatialValue(), and LayeredSideIntegral::spatialValue().

{
  unsigned int layer = getLayer(p);

  int higher_layer = -1;
  int lower_layer = -1;

  for (unsigned int i = layer; i < _layer_values.size(); i++)
  {
    if (_layer_has_value[i])
    {
      higher_layer = i;
      break;
    }
  }

  for (int i = layer - 1; i >= 0; i--)
  {
    if (_layer_has_value[i])
    {
      lower_layer = i;
      break;
    }
  }

  if (higher_layer == -1 && lower_layer == -1)
    return 0; // TODO: We could error here but there are startup dependency problems

  switch (_sample_type)
  {
    case 0: // direct
    {
      if (higher_layer == -1) // Didn't find a higher layer
        return _layer_values[lower_layer];

      if (unsigned(higher_layer) == layer) // constant in a layer
        return _layer_values[higher_layer];

      if (lower_layer == -1) // Didn't find a lower layer
        return _layer_values[higher_layer];

      return (_layer_values[higher_layer] + _layer_values[lower_layer]) / 2;
    }
    case 1: // interpolate
    {
      if (higher_layer == -1) // Didn't find a higher layer
        return _layer_values[lower_layer];

      Real layer_length = (_direction_max - _direction_min) / _num_layers;
      Real lower_coor = _direction_min;
      Real lower_value = 0;
      if (lower_layer != -1)
      {
        lower_coor += (lower_layer + 1) * layer_length;
        lower_value = _layer_values[lower_layer];
      }

      // Interpolate between the two points
      Real higher_value = _layer_values[higher_layer];

      // Linear interpolation
      return lower_value +
             (higher_value - lower_value) * (p(_direction) - lower_coor) / layer_length;
    }
    case 2: // average
    {
      Real total = 0;
      unsigned int num_values = 0;

      if (higher_layer != -1)
      {
        for (unsigned int i = 0; i < _average_radius; i++)
        {
          int current_layer = higher_layer + i;

          if ((size_t)current_layer >= _layer_values.size())
            break;

          if (_layer_has_value[current_layer])
          {
            total += _layer_values[current_layer];
            num_values += 1;
          }
        }
      }

      if (lower_layer != -1)
      {
        for (unsigned int i = 0; i < _average_radius; i++)
        {
          int current_layer = lower_layer - i;

          if (current_layer < 0)
            break;

          if (_layer_has_value[current_layer])
          {
            total += _layer_values[current_layer];
            num_values += 1;
          }
        }
      }

      return total / num_values;
    }
    default:
      mooseError("Unknown sample type!");
  }
}

layerHasValue()

bool LayeredBase::layerHasValue ( unsigned int  layer ) const

inlineprotected

Whether or not a layer has a value.

Definition at line 82 of file LayeredBase.h.

Referenced by LayeredAverage::finalize(), LayeredSideAverage::finalize(), LayeredSideAverage::threadJoin(), and threadJoin().

{ return _layer_has_value[layer]; }

setLayerValue()

void LayeredBase::setLayerValue ( unsigned int  layer, Real  value  )

protected

Set the value for a particular layer.

Parameters

layer	The layer you are setting the value for
value	The value to set

Definition at line 316 of file LayeredBase.C.

Referenced by LayeredIntegral::execute(), LayeredSideIntegral::execute(), LayeredAverage::finalize(), LayeredSideAverage::finalize(), finalize(), and threadJoin().

{
  _layer_values[layer] = value;
  _layer_has_value[layer] = true;
}

threadJoin()

void LayeredBase::threadJoin ( const UserObject &  y )

virtual

Reimplemented in LayeredSideIntegral, LayeredIntegral, LayeredSideAverage, and LayeredAverage.

Definition at line 267 of file LayeredBase.C.

Referenced by LayeredIntegral::threadJoin(), and LayeredSideIntegral::threadJoin().

{
  const LayeredBase & lb = dynamic_cast<const LayeredBase &>(y);
  for (unsigned int i = 0; i < _layer_values.size(); i++)
    if (lb.layerHasValue(i))
      setLayerValue(i, getLayerValue(i) + lb._layer_values[i]);
}

Member Data Documentation

_average_radius

unsigned int LayeredBase::_average_radius

protected

How many layers both above and below the found layer will be used in the average.

Definition at line 114 of file LayeredBase.h.

Referenced by integralValue().

_blocks

std::vector<SubdomainID> LayeredBase::_blocks

private

List of SubdomainIDs, if given.

Definition at line 136 of file LayeredBase.h.

Referenced by getBounds(), and LayeredBase().

_cumulative

bool LayeredBase::_cumulative

private

Whether the values are cumulative over the layers.

Definition at line 133 of file LayeredBase.h.

Referenced by finalize().

_direction

unsigned int LayeredBase::_direction

protected

The component direction the layers are going in. We cache this for speed (so we're not always going through the MooseEnum)

Definition at line 99 of file LayeredBase.h.

Referenced by getBounds(), getLayer(), and integralValue().

_direction_enum

MooseEnum LayeredBase::_direction_enum

protected

The MooseEnum direction the layers are going in.

Definition at line 96 of file LayeredBase.h.

_direction_max

Real LayeredBase::_direction_max

protected

Definition at line 120 of file LayeredBase.h.

Referenced by getBounds(), getLayer(), and integralValue().

_direction_min

Real LayeredBase::_direction_min

protected

Definition at line 119 of file LayeredBase.h.

Referenced by getBounds(), getLayer(), and integralValue().

_interval_based

bool LayeredBase::_interval_based

protected

Whether or not this object is based on equally spaced intervals or "bounds".

Definition at line 102 of file LayeredBase.h.

Referenced by getLayer(), and LayeredBase().

_layer_bounds

std::vector<Real> LayeredBase::_layer_bounds

protected

The boundaries of the layers.

Definition at line 108 of file LayeredBase.h.

Referenced by getLayer(), and LayeredBase().

_layer_has_value

std::vector<int>& LayeredBase::_layer_has_value

private

Whether or not each layer has had any value summed into it.

Definition at line 127 of file LayeredBase.h.

Referenced by finalize(), initialize(), integralValue(), LayeredBase(), layerHasValue(), and setLayerValue().

_layer_values

std::vector<Real>& LayeredBase::_layer_values

private

Value of the integral for each layer.

Definition at line 124 of file LayeredBase.h.

Referenced by finalize(), getLayerValue(), initialize(), integralValue(), LayeredBase(), setLayerValue(), and threadJoin().

_layered_base_name

std::string LayeredBase::_layered_base_name

protected

Name of this object.

Definition at line 90 of file LayeredBase.h.

Referenced by getLayerValue(), and LayeredBase().

_layered_base_params

const InputParameters& LayeredBase::_layered_base_params

protected

Params for this object.

Definition at line 93 of file LayeredBase.h.

Referenced by LayeredBase().

_layered_base_subproblem

SubProblem& LayeredBase::_layered_base_subproblem

private

Subproblem for the child object.

Definition at line 130 of file LayeredBase.h.

Referenced by finalize(), getBounds(), and LayeredBase().

_num_layers

unsigned int LayeredBase::_num_layers

protected

Number of layers to split the mesh into.

Definition at line 105 of file LayeredBase.h.

Referenced by finalize(), getLayer(), integralValue(), LayeredAverage::LayeredAverage(), LayeredBase(), and LayeredSideAverage::LayeredSideAverage().

_sample_type

unsigned int LayeredBase::_sample_type

protected

How to sample the values.

Definition at line 111 of file LayeredBase.h.

Referenced by integralValue(), and LayeredBase().

_using_displaced_mesh

bool LayeredBase::_using_displaced_mesh

protected

true if this object operates on the displaced mesh, otherwise false

Definition at line 117 of file LayeredBase.h.

Referenced by initialize().

---

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

• include/userobject/LayeredBase.h
• src/userobject/LayeredBase.C