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. More...

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. More...

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. More...

virtual void	initialize ()
	Initialize the datastructures. More...

virtual void	finalize ()
	Finalize the values. More...

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

Protected Attributes
const InputParameters &	_sampler_params
	The child params. More...

VectorPostprocessor *	_vpp
	The child VectorPostprocessor. More...

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

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

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

const unsigned int	_sort_by
	What to sort by. More...

VectorPostprocessorValue &	_x
	x coordinate of the points More...

VectorPostprocessorValue &	_y
	y coordinate of the points More...

VectorPostprocessorValue &	_z
	x coordinate of the points More...

VectorPostprocessorValue &	_id
	The node ID of each point. More...

std::vector< VectorPostprocessorValue * >	_values

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

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

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

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 38 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(parameters.get<MooseEnum>("sort_by")),
     _x(vpp->declareVector("x")),
     _y(vpp->declareVector("y")),
     _z(vpp->declareVector("z")),
     _id(vpp->declareVector("id"))
 {
 }

◆ ~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 67 of file SamplerBase.C.

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

 {
   _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++;
 }

◆ 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 129 of file SamplerBase.C.

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

 {
   // 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");
 }

◆ 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 LineMaterialSamplerBase< T >, LineMaterialSamplerBase< Real >, PointSamplerBase, ElementValueSampler, NodalValueSampler, LineFunctionSampler, and SideValueSampler.

Definition at line 156 of file SamplerBase.C.

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

 {
   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]->begin(), vec_ptrs[_sort_by]->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();
     }
   }
 }

◆ initialize()

void SamplerBase::initialize ( )

protectedvirtual

Initialize the datastructures.

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

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

Definition at line 83 of file SamplerBase.C.

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

 {
   // 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;
 }

◆ 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 57 of file SamplerBase.C.

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

 {
   _variable_names = variable_names;
   _values.reserve(variable_names.size());
 
   for (const auto & variable_name : variable_names)
     _values.push_back(&_vpp->declareVector(variable_name));
 }

◆ 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.

Definition at line 222 of file SamplerBase.C.

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

 {
   _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;
 }

◆ validParams()

InputParameters SamplerBase::validParams ( )

static

Definition at line 24 of file SamplerBase.C.

Referenced by SideValueSampler::validParams(), LineFunctionSampler::validParams(), NodalValueSampler::validParams(), ElementValueSampler::validParams(), PointVariableSamplerBase::validParams(), PointSamplerBase::validParams(), and LineMaterialSamplerBase< Real >::validParams().

 {
   InputParameters params = emptyInputParameters();
 
   MooseEnum sort_options("x y z id");
   params.addRequiredParam<MooseEnum>("sort_by", sort_options, "What to sort the samples by");
 
   // 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;
 }