LayeredBase Class Reference

This base class 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 (const 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 (const Point &p) const
	Helper function to return the layer the point lies in. More...
const std::vector< Real > &	getLayerCenters () const
	Get the center coordinates for the layers (along given direction) More...
unsigned int	direction () const
	Get direction of the layers. More...
virtual void	initialize ()
virtual void	finalize ()
virtual void	threadJoin (const UserObject &y)

Static Public Member Functions
static InputParameters	validParams ()

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...
void	computeLayerCenters ()
	Compute the center points for each layer. 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...
std::vector< Real >	_layer_centers
	center coordinates of each layer More...
Real	_direction_min
Real	_direction_max
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...
bool	_cumulative
	Whether the values are cumulative over the layers. More...
const bool	_positive_cumulative_direction
	Whether the cumulative values should be summed in the positive or negative direction. More...

Private Member Functions
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...

Private Attributes
SubProblem &	_layered_base_subproblem
	Subproblem for the child object. More...
std::vector< SubdomainID >	_layer_bounding_blocks
	List of SubdomainIDs, if given. More...
bool	_has_direction_max_min
	whether the max/min coordinate in the direction is known from user input More...
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...

Detailed Description

This base class computes volume integrals of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).

Definition at line 36 of file LayeredBase.h.

Constructor & Destructor Documentation

LayeredBase()

LayeredBase::LayeredBase

(

const InputParameters &

parameters

)

Definition at line 85 of file LayeredBase.C.

  : Restartable(parameters.getCheckedPointerParam<SubProblem *>("_subproblem")->getMooseApp(),
                parameters.getObjectName() + "_layered_base",
                "LayeredBase",
                parameters.get<THREAD_ID>("_tid")),
    _layered_base_name(parameters.getObjectName()),
    _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")),
    _cumulative(parameters.get<bool>("cumulative")),
    _positive_cumulative_direction(parameters.get<bool>("positive_cumulative_direction")),
    _layered_base_subproblem(*parameters.getCheckedPointerParam<SubProblem *>("_subproblem")),
    _layer_bounding_blocks(),
    _has_direction_max_min(false)
{
  if (_layered_base_params.isParamValid("num_layers") &&
      _layered_base_params.isParamValid("bounds"))
    mooseError("'bounds' and 'num_layers' cannot both be set");

  if (!_cumulative && parameters.isParamSetByUser("positive_cumulative_direction"))
    mooseWarning(
        "The 'positive_cumulative_direction' parameter is unused when 'cumulative' is false");

  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");

    if (_layer_bounds.size() < 2)
      mooseError("At least two boundaries must be provided in 'bounds' to form layers!");

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

    if (_layered_base_params.isParamValid("bound_splits") &&
        _layered_base_params.isParamValid("bound_uniform_splits"))
      mooseError("Parameters 'bound_splits' and 'bound_uniform_splits' cannot be both supplied");

    // If requested, we uniformly split the layers.
    if (_layered_base_params.isParamValid("bound_uniform_splits"))
    {
      const auto splits = _layered_base_params.get<unsigned int>("bound_uniform_splits");
      for (unsigned int s = 0; s < splits; ++s)
      {
        std::vector<Real> new_bnds;
        new_bnds.reserve(2 * (_layer_bounds.size() - 1) + 1);
        for (unsigned int i = 0; i < _layer_bounds.size() - 1; ++i)
        {
          new_bnds.emplace_back(_layer_bounds[i]);
          new_bnds.emplace_back(0.5 * (_layer_bounds[i] + _layer_bounds[i + 1]));
        }
        new_bnds.emplace_back(_layer_bounds.back());
        _layer_bounds = new_bnds;
      }
    }

    if (_layered_base_params.isParamValid("bound_splits"))
    {
      // expand layers with subdivisions
      const auto nsubs = _layered_base_params.get<std::vector<unsigned int>>("bound_splits");
      if (nsubs.size() != _layer_bounds.size() - 1)
        mooseError("'bound_splits' size must be equal to the size of 'bounds' minus one");

      std::vector<Real> new_layers;
      new_layers.reserve(std::accumulate(nsubs.begin(), nsubs.end(), (unsigned int)0));
      new_layers.push_back(_layer_bounds[0]);
      for (const auto i : index_range(nsubs))
      {
        Real dz = (_layer_bounds[i + 1] - _layer_bounds[i]) / nsubs[i];
        for (const auto j : make_range(nsubs[i]))
        {
          libmesh_ignore(j);
          new_layers.push_back(new_layers.back() + dz);
        }
      }
      _layer_bounds = new_layers;
    }

    _num_layers = _layer_bounds.size() - 1; // Layers are only in-between the bounds
    _direction_min = _layer_bounds.front();
    _direction_max = _layer_bounds.back();
    _has_direction_max_min = true;
  }
  else
    mooseError("One of 'bounds' or 'num_layers' must be specified");

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

  bool has_layer_bounding_block = _layered_base_params.isParamValid("layer_bounding_block");
  bool has_block = _layered_base_params.isParamValid("block");
  bool has_direction_min = _layered_base_params.isParamValid("direction_min");
  bool has_direction_max = _layered_base_params.isParamValid("direction_max");

  if (_has_direction_max_min && has_direction_min)
    mooseWarning("'direction_min' is unused when providing 'bounds'");

  if (_has_direction_max_min && has_direction_max)
    mooseWarning("'direction_max' is unused when providing 'bounds'");

  // can only specify one of layer_bounding_block or the pair direction_max/min
  if (has_layer_bounding_block && (has_direction_min || has_direction_max))
    mooseError("Only one of 'layer_bounding_block' and the pair 'direction_max' and "
               "'direction_min' can be provided");

  // if either one of direction_min or direction_max is specified, must provide the other one
  if (has_direction_min != has_direction_max)
    mooseError("If providing the layer max/min directions, both 'direction_max' and "
               "'direction_min' must be specified.");

  if (has_layer_bounding_block)
    _layer_bounding_blocks = _layered_base_subproblem.mesh().getSubdomainIDs(
        _layered_base_params.get<std::vector<SubdomainName>>("layer_bounding_block"));
  else if (has_block)
    _layer_bounding_blocks = _layered_base_subproblem.mesh().getSubdomainIDs(
        _layered_base_params.get<std::vector<SubdomainName>>("block"));

  // specifying the direction max/min overrides anything set with the 'block'
  if (has_direction_min && has_direction_max)
  {
    _direction_min = parameters.get<Real>("direction_min");
    _direction_max = parameters.get<Real>("direction_max");
    _has_direction_max_min = true;

    if (_direction_max <= _direction_min)
      mooseError("'direction_max' must be larger than 'direction_min'");
  }

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

  // if we haven't already figured out the max/min in specified direction
  // (either with the 'bounds' or explicit specification from the user), do so
  if (!_has_direction_max_min)
    getBounds();

  computeLayerCenters();
}

Member Function Documentation

computeLayerCenters()

void LayeredBase::computeLayerCenters ( )

protected

Compute the center points for each layer.

Definition at line 442 of file LayeredBase.C.

Referenced by LayeredBase().

{
  _layer_centers.resize(_num_layers);

  if (_interval_based)
  {
    Real dx = (_direction_max - _direction_min) / _num_layers;

    for (const auto i : make_range(_num_layers))
      _layer_centers[i] = (i + 0.5) * dx;
  }
  else
  {
    for (const auto i : make_range(_num_layers))
      _layer_centers[i] = 0.5 * (_layer_bounds[i + 1] + _layer_bounds[i]);
  }
}

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "recoverable" 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)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);

  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);

  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

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)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

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)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

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.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

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
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);

  _restartable_name = old_name;

  return value;
}

direction()

unsigned int LayeredBase::direction ( ) const

inline

Get direction of the layers.

Returns

layer direction

Definition at line 73 of file LayeredBase.h.

{ return _direction; }

finalize()

void LayeredBase::finalize ( )

virtual

Reimplemented in FunctionLayeredIntegral, LayeredExtremumMaterialProperty, LayeredIntegralBase< UserObjectType >, LayeredIntegralBase< SideIntegralFunctorUserObject >, LayeredIntegralBase< SideIntegralVariableUserObject >, LayeredIntegralBase< ElementIntegralFunctorUserObject >, LayeredIntegralBase< BaseType >, LayeredIntegralBase< ElementIntegralVariableUserObject >, LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 368 of file LayeredBase.C.

Referenced by LayeredIntegralBase< ElementIntegralVariableUserObject >::finalize(), and FunctionLayeredIntegral::finalize().

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

  if (_cumulative)
  {
    Real value = 0;

    if (_positive_cumulative_direction)
      for (const auto i : make_range(_num_layers))
      {
        value += getLayerValue(i);
        setLayerValue(i, value);
      }
    else
      for (int i = _num_layers - 1; i >= 0; i--)
      {
        value += getLayerValue(i);
        setLayerValue(i, value);
      }
  }
}

getBounds()

void LayeredBase::getBounds ( )

protected

Compute bounds, restricted to blocks if given.

Definition at line 468 of file LayeredBase.C.

Referenced by initialize(), and LayeredBase().

{
  if (_layer_bounding_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(_layer_bounding_blocks.begin(), _layer_bounding_blocks.end(), subdomain_id) ==
          _layer_bounding_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 ( const 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 402 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::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));
  }
}

getLayerCenters()

const std::vector<Real>& LayeredBase::getLayerCenters ( ) const

inline

Get the center coordinates for the layers (along given direction)

Definition at line 67 of file LayeredBase.h.

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

{ return _layer_centers; }

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 347 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::execute(), LayeredExtremumMaterialProperty::finalize(), finalize(), LayeredExtremumMaterialProperty::threadJoin(), and threadJoin().

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

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

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

Parameters

data_name

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

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

initialize()

void LayeredBase::initialize ( )

virtual

Reimplemented in FunctionLayeredIntegral, LayeredExtremumMaterialProperty, LayeredIntegralBase< UserObjectType >, LayeredIntegralBase< SideIntegralFunctorUserObject >, LayeredIntegralBase< SideIntegralVariableUserObject >, LayeredIntegralBase< ElementIntegralFunctorUserObject >, LayeredIntegralBase< BaseType >, LayeredIntegralBase< ElementIntegralVariableUserObject >, LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 355 of file LayeredBase.C.

Referenced by LayeredIntegralBase< ElementIntegralVariableUserObject >::initialize(), LayeredExtremumMaterialProperty::initialize(), and FunctionLayeredIntegral::initialize().

{
  if (_using_displaced_mesh)
    getBounds();

  for (const auto i : index_range(_layer_values))
  {
    _layer_values[i] = 0.0;
    _layer_has_value[i] = false;
  }
}

integralValue()

Real LayeredBase::integralValue ( const 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 236 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::spatialValue(), LayeredIntegralBase< ElementIntegralVariableUserObject >::spatialValue(), and FunctionLayeredIntegral::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 (const auto i : make_range(_average_radius))
        {
          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 (const auto i : make_range(_average_radius))
        {
          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 90 of file LayeredBase.h.

{ return _layer_has_value[layer]; }

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

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 461 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::execute(), LayeredExtremumMaterialProperty::finalize(), finalize(), LayeredExtremumMaterialProperty::initialize(), LayeredExtremumMaterialProperty::threadJoin(), and threadJoin().

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

threadJoin()

void LayeredBase::threadJoin ( const UserObject &  y )

virtual

Reimplemented in FunctionLayeredIntegral, LayeredExtremumMaterialProperty, LayeredIntegralBase< UserObjectType >, LayeredIntegralBase< SideIntegralFunctorUserObject >, LayeredIntegralBase< SideIntegralVariableUserObject >, LayeredIntegralBase< ElementIntegralFunctorUserObject >, LayeredIntegralBase< BaseType >, LayeredIntegralBase< ElementIntegralVariableUserObject >, LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 393 of file LayeredBase.C.

Referenced by LayeredIntegralBase< ElementIntegralVariableUserObject >::threadJoin(), and FunctionLayeredIntegral::threadJoin().

{
  const auto & lb = dynamic_cast<const LayeredBase &>(y);
  for (const auto i : index_range(_layer_values))
    if (lb.layerHasValue(i))
      setLayerValue(i, getLayerValue(i) + lb._layer_values[i]);
}

validParams()

InputParameters LayeredBase::validParams ( )

static

Definition at line 22 of file LayeredBase.C.

Referenced by LayeredIntegralBase< ElementIntegralVariableUserObject >::validParams(), LayeredExtremumMaterialProperty::validParams(), and FunctionLayeredIntegral::validParams().

{
  InputParameters params = emptyInputParameters();
  MooseEnum directions("x y z");

  params.addRequiredParam<MooseEnum>("direction", directions, "The direction of the layers.");
  params.addParam<unsigned int>("num_layers", "The number of layers.");
  params.addParam<std::vector<Real>>("bounds",
                                     "The 'bounding' positions of the layers i.e.: '0, "
                                     "1.2, 3.7, 4.2' will mean 3 layers between those "
                                     "positions.");
  params.addRangeCheckedParam<unsigned int>("bound_uniform_splits",
                                            "bound_uniform_splits > 0",
                                            "The number of times the bins specified in 'bounds' "
                                            "should be split uniformly.");
  params.addParam<std::vector<unsigned int>>(
      "bound_splits", "Number of uniform splits of all layers in 'bounds' (default to all ones)");

  MooseEnum sample_options("direct interpolate average", "direct");
  params.addParam<MooseEnum>("sample_type",
                             sample_options,
                             "How to sample the layers.  'direct' means get the value of the layer "
                             "the point falls in directly (or average if that layer has no value). "
                             " 'interpolate' does a linear interpolation between the two closest "
                             "layers.  'average' averages the two closest layers.");

  params.addParam<unsigned int>("average_radius",
                                1,
                                "When using 'average' sampling this is how "
                                "the number of values both above and below "
                                "the layer that will be averaged.");

  params.addParam<bool>(
      "cumulative",
      false,
      "When true the value in each layer is the sum of the values up to and including that layer");
  params.addParam<bool>(
      "positive_cumulative_direction",
      true,
      "When 'cumulative' is true, whether the direction for summing the cumulative value "
      "is the positive direction or negative direction");

  params.addParam<std::vector<SubdomainName>>(
      "block", "The list of block ids (SubdomainID) that this object will be applied");

  params.addParam<std::vector<SubdomainName>>("layer_bounding_block",
                                              "List of block ids (SubdomainID) that are used to "
                                              "determine the upper and lower geometric bounds for "
                                              "all layers. If this is not specified, the ids "
                                              "specified in 'block' are used for this purpose.");

  params.addParam<Real>("direction_min",
                        "Minimum coordinate along 'direction' that bounds the layers");
  params.addParam<Real>("direction_max",
                        "Maximum coordinate along 'direction' that bounds the layers");
  params.addParamNamesToGroup(
      "direction num_layers bounds direction_min direction_max bound_uniform_splits bound_splits",
      "Layers extent and definition");
  params.addParamNamesToGroup("sample_type average_radius cumulative positive_cumulative_direction",
                              "Value sampling / aggregating");
  return params;
}

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 127 of file LayeredBase.h.

Referenced by integralValue().

_cumulative

bool LayeredBase::_cumulative

protected

Whether the values are cumulative over the layers.

Definition at line 145 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), finalize(), and LayeredBase().

_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 112 of file LayeredBase.h.

Referenced by direction(), getBounds(), getLayer(), integralValue(), LayeredExtremumMaterialProperty::spatialPoints(), and FunctionLayeredIntegral::spatialPoints().

_direction_enum

MooseEnum LayeredBase::_direction_enum

protected

The MooseEnum direction the layers are going in.

Definition at line 109 of file LayeredBase.h.

_direction_max

Real LayeredBase::_direction_max

protected

Definition at line 136 of file LayeredBase.h.

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

_direction_min

Real LayeredBase::_direction_min

protected

Definition at line 135 of file LayeredBase.h.

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

_has_direction_max_min

bool LayeredBase::_has_direction_max_min

private

whether the max/min coordinate in the direction is known from user input

Definition at line 158 of file LayeredBase.h.

Referenced by LayeredBase().

_interval_based

bool LayeredBase::_interval_based

protected

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

Definition at line 115 of file LayeredBase.h.

Referenced by computeLayerCenters(), getLayer(), and LayeredBase().

_layer_bounding_blocks

std::vector<SubdomainID> LayeredBase::_layer_bounding_blocks

private

List of SubdomainIDs, if given.

Definition at line 155 of file LayeredBase.h.

Referenced by getBounds(), and LayeredBase().

_layer_bounds

std::vector<Real> LayeredBase::_layer_bounds

protected

The boundaries of the layers.

Definition at line 121 of file LayeredBase.h.

Referenced by computeLayerCenters(), getLayer(), and LayeredBase().

_layer_centers

std::vector<Real> LayeredBase::_layer_centers

protected

center coordinates of each layer

Definition at line 133 of file LayeredBase.h.

Referenced by computeLayerCenters(), getLayerCenters(), LayeredExtremumMaterialProperty::spatialPoints(), and FunctionLayeredIntegral::spatialPoints().

_layer_has_value

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

protected

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

Definition at line 142 of file LayeredBase.h.

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

_layer_values

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

protected

Value of the integral for each layer.

Definition at line 139 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), 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 103 of file LayeredBase.h.

Referenced by getLayerValue().

_layered_base_params

const InputParameters& LayeredBase::_layered_base_params

protected

Params for this object.

Definition at line 106 of file LayeredBase.h.

Referenced by LayeredBase().

_layered_base_subproblem

SubProblem& LayeredBase::_layered_base_subproblem

private

Subproblem for the child object.

Definition at line 152 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 118 of file LayeredBase.h.

Referenced by computeLayerCenters(), LayeredExtremumMaterialProperty::finalize(), finalize(), getLayer(), LayeredExtremumMaterialProperty::initialize(), integralValue(), LayeredAverageBase< ElementIntegralVariableUserObject >::LayeredAverageBase(), LayeredBase(), and LayeredExtremumMaterialProperty::threadJoin().

_positive_cumulative_direction

const bool LayeredBase::_positive_cumulative_direction

protected

Whether the cumulative values should be summed in the positive or negative direction.

Definition at line 148 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), and finalize().

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_sample_type

unsigned int LayeredBase::_sample_type

protected

How to sample the values.

Definition at line 124 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 130 of file LayeredBase.h.

Referenced by initialize().

---

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

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