Base class for VectorPostprocessors that need to do "sampling" of values in the domain. More...

#include <SamplerBase.h>

Inheritance diagram for SamplerBase:

Public Member Functions
	SamplerBase (const InputParameters &parameters, VectorPostprocessor *vpp, const libMesh::Parallel::Communicator &comm)

virtual	~SamplerBase ()=default

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	setupVariables (const std::vector< std::string > &variable_names)
	You MUST call this in the constructor of the child class and pass down the name of the variables.

void	checkForStandardFieldVariableType (const MooseVariableFieldBase *const var_ptr, const std::string &var_param_name="variable") const
	Checks whether the passed variable pointer corresponds to a regular single-valued field variable.

virtual void	addSample (const Point &p, const Real &id, const std::vector< Real > &values)
	Call this with the value of every variable at each point you want to sample at.

virtual void	initialize ()
	Initialize the datastructures.

virtual void	finalize ()
	Finalize the values.

virtual void	threadJoin (const SamplerBase &y)
	Join the values.

Protected Attributes
const InputParameters &	_sampler_params
	The child params.

VectorPostprocessor *	_vpp
	The child VectorPostprocessor.

const libMesh::Parallel::Communicator &	_comm
	The communicator of the child.

const TransientBase *const	_sampler_transient
	Transient executioner used to determine if the last solve converged.

std::vector< std::string >	_variable_names
	The variable names.

unsigned int	_sort_by_index
	The index for what to sort by: x=0, y=1, z=2, then sampled variables in ordered specified in the parameter.

VectorPostprocessorValue &	_x
	x coordinate of the points

VectorPostprocessorValue &	_y
	y coordinate of the points

VectorPostprocessorValue &	_z
	x coordinate of the points

VectorPostprocessorValue &	_id
	The node ID of each point.

std::vector< VectorPostprocessorValue * >	_values

Private Attributes
const std::string	_sort_by
	What to sort by.

std::size_t	_curr_num_samples = 0
	The number of samples added in the last execution.

std::set< std::size_t, std::greater< std::size_t > >	_curr_indices
	The indices of the samples in the last execution.

std::size_t	_curr_total_samples = 0
	The full size of the vector since the last execution.

Detailed Description

Base class for VectorPostprocessors that need to do "sampling" of values in the domain.

Definition at line 37 of file SamplerBase.h.

Constructor & Destructor Documentation

◆ SamplerBase()

SamplerBase::SamplerBase	(	const InputParameters &	parameters,
		VectorPostprocessor *	vpp,
		const libMesh::Parallel::Communicator &	comm
	)

Parameters

parameters	The parameters for the object
vpp	A pointer to the child object
comm	The communicator of the child

Definition at line 40 of file SamplerBase.C.

  : _sampler_params(parameters),
    _vpp(vpp),
    _comm(comm),
    _sampler_transient(dynamic_cast<TransientBase *>(
        parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")
            ->getMooseApp()
            .getExecutioner())),
    _sort_by_index(libMesh::invalid_uint),
    _x(vpp->declareVector("x")),
    _y(vpp->declareVector("y")),
    _z(vpp->declareVector("z")),
    _id(vpp->declareVector("id")),
    _sort_by(parameters.get<std::string>("sort_by"))
{
  if (_sort_by == "x")
    _sort_by_index = 0;
  else if (_sort_by == "y")
    _sort_by_index = 1;
  else if (_sort_by == "z")
    _sort_by_index = 2;
  else if (_sort_by == "id")
    _sort_by_index = 3;
  // Sort by index for variables determined in setupVariables()
}

◆ ~SamplerBase()

virtual SamplerBase::~SamplerBase ( )

virtualdefault

Member Function Documentation

◆ addSample()

void SamplerBase::addSample	(	const Point &	p,
		const Real &	id,
		const std::vector< Real > &	values
	)

protectedvirtual

Call this with the value of every variable at each point you want to sample at.

Parameters

p	The point where you took the sample
id	This can either be an actual ID or a distance or anything else you want
values	The value of each variable

Definition at line 91 of file SamplerBase.C.

{
  _x.push_back(p(0));
  _y.push_back(p(1));
  _z.push_back(p(2));
 
  _id.push_back(id);
 
  mooseAssert(values.size() == _variable_names.size(), "Mismatch of variable names to vector size");
  for (MooseIndex(values) i = 0; i < values.size(); ++i)
    _values[i]->emplace_back(values[i]);
 
  _curr_num_samples++;
}

Referenced by ElementValueSampler::execute(), LineFunctionSampler::execute(), NodalValueSampler::execute(), SideValueSampler::execute(), and PointSamplerBase::finalize().

◆ checkForStandardFieldVariableType()

void SamplerBase::checkForStandardFieldVariableType	(	const MooseVariableFieldBase *const	var_ptr,
		const std::string &	var_param_name = `"variable"`
	)		const

protected

Checks whether the passed variable pointer corresponds to a regular single-valued field variable.

Parameters

var_param_name	name of the variable parameter in which the variables were passed
var_ptr	pointer to the field variable

Definition at line 153 of file SamplerBase.C.

{
  // A pointer to a MooseVariableFieldBase should never be SCALAR
  mooseAssert(var_ptr->feType().family != SCALAR,
              "Scalar variable '" + var_ptr->name() + "' cannot be sampled.");
  mooseAssert(dynamic_cast<const MooseObject *>(_vpp), "Should have succeeded");
  if (var_ptr->isVector())
    dynamic_cast<const MooseObject *>(_vpp)->paramError(
        var_param_name,
        "The variable '",
        var_ptr->name(),
        "' is a vector variable. Sampling those is not currently supported in the "
        "framework. It may be supported using a dedicated object in your application. Use "
        "'VectorVariableComponentAux' auxkernel to copy those values into a regular field "
        "variable");
  if (var_ptr->isArray())
    dynamic_cast<const MooseObject *>(_vpp)->paramError(
        var_param_name,
        "The variable '",
        var_ptr->name(),
        "' is an array variable. Sampling those is not currently supported in the "
        "framework. It may be supported using a dedicated object in your application. Use "
        "'ArrayVariableComponent' auxkernel to copy those values into a regular field variable");
}

Referenced by ElementValueSampler::ElementValueSampler(), NodalValueSampler::NodalValueSampler(), PointVariableSamplerBase::PointVariableSamplerBase(), and SideValueSampler::SideValueSampler().

◆ finalize()

void SamplerBase::finalize ( )

protectedvirtual

Finalize the values.

YOU MUST CALL THIS DURING finalize() in the child class!

We have several vectors that all need to be processed in the same way. Rather than enumerate them all, let's just create a vector of pointers and work on them that way.

We now have one sorted vector. The remaining vectors need to be sorted according to that vector. We'll need a temporary vector to hold values as we map them according to the sorted indices. After that, we'll swap the vector contents with the sorted vector to get the values back into the original vector.

Reimplemented in PointSamplerBase, ElementValueSampler, LineFunctionSampler, LineMaterialSamplerBase< T >, LineMaterialSamplerBase< Real >, NodalValueSampler, and SideValueSampler.

Definition at line 180 of file SamplerBase.C.

{
  constexpr auto NUM_ID_VECTORS = 4;
 
  std::vector<VectorPostprocessorValue *> vec_ptrs;
  vec_ptrs.reserve(_values.size() + NUM_ID_VECTORS);
  // Initialize the pointer vector with the position and ID vectors
  vec_ptrs = {{&_x, &_y, &_z, &_id}};
  // Now extend the vector by all the remaining values vector before processing
  vec_ptrs.insert(vec_ptrs.end(), _values.begin(), _values.end());
 
  // Gather up each of the partial vectors
  for (auto vec_ptr : vec_ptrs)
    _comm.allgather(*vec_ptr, /* identical buffer lengths = */ false);
 
  // Now create an index vector by using an indirect sort
  std::vector<std::size_t> sorted_indices;
  Moose::indirectSort(
      vec_ptrs[_sort_by_index]->begin(), vec_ptrs[_sort_by_index]->end(), sorted_indices);
 
  // This vector is used as temp storage to sort each of the remaining vectors according to the
  // first
  auto vector_length = sorted_indices.size();
  VectorPostprocessorValue tmp_vector(vector_length);
 
#ifndef NDEBUG
  for (const auto vec_ptr : vec_ptrs)
    if (vec_ptr->size() != vector_length)
      mooseError("Vector length mismatch");
#endif
 
  // Sort each of the vectors using the same sorted indices
  for (auto & vec_ptr : vec_ptrs)
  {
    for (MooseIndex(sorted_indices) j = 0; j < sorted_indices.size(); ++j)
      tmp_vector[j] = (*vec_ptr)[sorted_indices[j]];
 
    // Swap vector storage with sorted vector
    vec_ptr->swap(tmp_vector);
  }
 
  // Gather the indices of samples from the last execution
  // Used to determine which parts of the vector need to be erased if a solve fails
  if (_vpp->containsCompleteHistory())
  {
    _comm.sum(_curr_num_samples);
    if (_comm.rank() == 0)
    {
      _curr_indices.insert(sorted_indices.end() - _curr_num_samples, sorted_indices.end());
      _curr_total_samples = vec_ptrs[0]->size();
    }
  }
}

Referenced by PointSamplerBase::finalize(), ElementValueSampler::finalize(), LineFunctionSampler::finalize(), LineMaterialSamplerBase< T >::finalize(), NodalValueSampler::finalize(), and SideValueSampler::finalize().

◆ initialize()

void SamplerBase::initialize ( )

protectedvirtual

Initialize the datastructures.

YOU MUST CALL THIS DURING initialize() in the child class!

Reimplemented in PointSamplerBase, PointVariableSamplerBase, ElementValueSampler, LineFunctionSampler, LineMaterialSamplerBase< T >, LineMaterialSamplerBase< Real >, NodalValueSampler, PositionsFunctorValueSampler, and SideValueSampler.

Definition at line 107 of file SamplerBase.C.

{
  // Don't reset the vectors if we want to retain history
  if (_vpp->containsCompleteHistory() && _comm.rank() == 0)
  {
    // If we are repeating the timestep due to an aborted solve, we want to throw away the last
    // values
    if (_sampler_transient && !_sampler_transient->lastSolveConverged())
    {
      // Convenient to allocate a single variable for all the vpp values
      std::vector<VectorPostprocessorValue *> vec_ptrs = {{&_x, &_y, &_z, &_id}};
      vec_ptrs.insert(vec_ptrs.end(), _values.begin(), _values.end());
      // Erase the elements from the last execution
      for (auto vec_ptr : vec_ptrs)
      {
        // Vector may have already been restored, if so, skip the erasure
        if (_curr_total_samples > vec_ptr->size())
        {
          mooseAssert(vec_ptr->size() == (_curr_total_samples - _curr_num_samples),
                      "Number of samples is not what is expected.");
          continue;
        }
        for (auto ind : _curr_indices)
        {
          mooseAssert(ind < vec_ptr->size(), "Trying to remove a sample that doesn't exist.");
          vec_ptr->erase(vec_ptr->begin() + ind);
        }
      }
    }
    _curr_indices.clear();
  }
  else
  {
    _x.clear();
    _y.clear();
    _z.clear();
    _id.clear();
 
    std::for_each(
        _values.begin(), _values.end(), [](VectorPostprocessorValue * vec) { vec->clear(); });
  }
 
  _curr_num_samples = 0;
}

Referenced by PointSamplerBase::initialize(), ElementValueSampler::initialize(), LineFunctionSampler::initialize(), LineMaterialSamplerBase< T >::initialize(), NodalValueSampler::initialize(), and SideValueSampler::initialize().

◆ setupVariables()

void SamplerBase::setupVariables ( const std::vector< std::string > & variable_names )

protected

You MUST call this in the constructor of the child class and pass down the name of the variables.

Parameters

variable_names The names of the variables. Note: The order of the variables sets the order of the values for addSample()

Definition at line 69 of file SamplerBase.C.

{
  _variable_names = variable_names;
  _values.reserve(variable_names.size());
 
  for (const auto & variable_name : variable_names)
    _values.push_back(&_vpp->declareVector(variable_name));
 
  // Find the index of the column to sort by for variables
  if (_sort_by_index == libMesh::invalid_uint)
  {
    const auto it = std::find(_variable_names.begin(), _variable_names.end(), _sort_by);
    if (it != _variable_names.end())
      _sort_by_index = 4 + it - _variable_names.begin();
    else
      mooseError(
          "The 'sort_by' parameter must be one of x/y/z/id or one of the sampled variable names: " +
          Moose::stringify(_variable_names));
  }
}

Referenced by ElementValueSampler::ElementValueSampler(), LineFunctionSampler::LineFunctionSampler(), LineMaterialSamplerBase< T >::LineMaterialSamplerBase(), NodalValueSampler::NodalValueSampler(), PointVariableSamplerBase::PointVariableSamplerBase(), PositionsFunctorValueSampler::PositionsFunctorValueSampler(), and SideValueSampler::SideValueSampler().

◆ threadJoin()

void SamplerBase::threadJoin ( const SamplerBase & y )

protectedvirtual

Join the values.

YOU MUST CALL THIS DURING threadJoin() in the child class!

Parameters

y	You must cast the UserObject to your child class type first then you can pass it in here.

Reimplemented in ElementValueSampler, NodalValueSampler, and SideValueSampler.

Definition at line 247 of file SamplerBase.C.

{
  _x.insert(_x.end(), y._x.begin(), y._x.end());
  _y.insert(_y.end(), y._y.begin(), y._y.end());
  _z.insert(_z.end(), y._z.begin(), y._z.end());
 
  _id.insert(_id.end(), y._id.begin(), y._id.end());
 
  for (MooseIndex(_variable_names) i = 0; i < _variable_names.size(); i++)
    _values[i]->insert(_values[i]->end(), y._values[i]->begin(), y._values[i]->end());
 
  _curr_num_samples += y._curr_num_samples;
}

Referenced by ElementValueSampler::threadJoin(), NodalValueSampler::threadJoin(), and SideValueSampler::threadJoin().

◆ validParams()

InputParameters SamplerBase::validParams ( )

static

Definition at line 24 of file SamplerBase.C.

{
  InputParameters params = emptyInputParameters();
 
  params.addRequiredParam<std::string>(
      "sort_by",
      "What to sort the samples by. Options include 'x', 'y', 'z', 'id', and the name of any of "
      "the sampled quantities (which each create a vector of the same name).");
 
  // The value from this VPP is naturally already on every processor
  // TODO: Make this not the case!  See #11415
  params.set<bool>("_auto_broadcast") = false;
 
  return params;
}