libMesh::MeshFunction Class Reference

This class provides function-like objects for data distributed over a mesh. More...

#include <mesh_function.h>

Inheritance diagram for libMesh::MeshFunction:

Public Member Functions
	MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, std::vector< unsigned int > vars, const FunctionBase< Number > *master=nullptr)
	Constructor for mesh based functions with vectors as return value.
	MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const unsigned int var, const FunctionBase< Number > *master=nullptr)
	Constructor for mesh based functions with a number as return value.
	MeshFunction (const MeshFunction &mf)
	A regular copy constructor.
	MeshFunction (MeshFunction &&)=default
	Special functions.
MeshFunction &	operator= (const MeshFunction &)=delete
MeshFunction &	operator= (MeshFunction &&)=delete
	~MeshFunction ()
	Destructor.
virtual void	init () override
	Override the FunctionBase::init() member function.
virtual void	clear () override
	Clears the function.
virtual std::unique_ptr< FunctionBase< Number > >	clone () const override
virtual Number	operator() (const Point &p, const Real time=0.) override
std::map< const Elem *, Number >	discontinuous_value (const Point &p, const Real time=0.)
Gradient	gradient (const Point &p, const Real time=0.)
std::map< const Elem *, Gradient >	discontinuous_gradient (const Point &p, const Real time=0.)
Tensor	hessian (const Point &p, const Real time=0.)
virtual void	operator() (const Point &p, const Real time, DenseVector< Number > &output) override
	Computes values at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.
void	operator() (const Point &p, const Real time, DenseVector< Number > &output, const std::set< subdomain_id_type > *subdomain_ids)
	Computes values at coordinate p and for time time, restricting the point to the passed subdomain_ids, which parameter overrides the internal subdomain_ids.
void	discontinuous_value (const Point &p, const Real time, std::map< const Elem *, DenseVector< Number > > &output)
	Similar to operator() with the same parameter list, but with the difference that multiple values on faces are explicitly permitted.
void	discontinuous_value (const Point &p, const Real time, std::map< const Elem *, DenseVector< Number > > &output, const std::set< subdomain_id_type > *subdomain_ids)
	Similar to operator() with the same parameter list, but with the difference that multiple values on faces are explicitly permitted.
void	gradient (const Point &p, const Real time, std::vector< Gradient > &output)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.
void	gradient (const Point &p, const Real time, std::vector< Gradient > &output, const std::set< subdomain_id_type > *subdomain_ids)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids, which parameter overrides the internal subdomain_ids.
void	discontinuous_gradient (const Point &p, const Real time, std::map< const Elem *, std::vector< Gradient > > &output)
	Similar to gradient, but with the difference that multiple values on faces are explicitly permitted.
void	discontinuous_gradient (const Point &p, const Real time, std::map< const Elem *, std::vector< Gradient > > &output, const std::set< subdomain_id_type > *subdomain_ids)
	Similar to gradient, but with the difference that multiple values on faces are explicitly permitted.
void	hessian (const Point &p, const Real time, std::vector< Tensor > &output)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.
void	hessian (const Point &p, const Real time, std::vector< Tensor > &output, const std::set< subdomain_id_type > *subdomain_ids)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids.
const PointLocatorBase &	get_point_locator () const
PointLocatorBase &	get_point_locator ()
void	enable_out_of_mesh_mode (const DenseVector< Number > &value)
	Enables out-of-mesh mode.
void	enable_out_of_mesh_mode (const Number &value)
	Enables out-of-mesh mode.
void	disable_out_of_mesh_mode ()
	Disables out-of-mesh mode.
void	set_point_locator_tolerance (Real tol)
	We may want to specify a tolerance for the PointLocator to use, since in some cases the point we want to evaluate at might be slightly outside the mesh (due to numerical rounding issues, for example).
void	unset_point_locator_tolerance ()
	Turn off the user-specified PointLocator tolerance.
void	set_subdomain_ids (const std::set< subdomain_id_type > *subdomain_ids)
	Choose a default list of subdomain ids to be searched for points.
void	operator() (const Point &p, DenseVector< Number > &output)
	Evaluation function for time-independent vector-valued functions.
virtual Number	component (unsigned int i, const Point &p, Real time=0.)
bool	initialized () const
void	set_is_time_dependent (bool is_time_dependent)
	Function to set whether this is a time-dependent function or not.
bool	is_time_dependent () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Protected Member Functions
const Elem *	find_element (const Point &p, const std::set< subdomain_id_type > *subdomain_ids=nullptr) const
	Helper function to reduce code duplication.
std::set< const Elem * >	find_elements (const Point &p, const std::set< subdomain_id_type > *subdomain_ids=nullptr) const
const Elem *	check_found_elem (const Elem *element, const Point &p) const
	Helper function that is called by MeshFunction::find_element() and MeshFunction::find_elements() to ensure that Elems found by the PointLocator are actually "evaluable" on the processor where they are found.
void	_gradient_on_elem (const Point &p, const Elem *element, std::vector< Gradient > &output)
	Helper function for finding a gradient as evaluated from a specific element.

Protected Attributes
const EquationSystems &	_eqn_systems
	The equation systems handler, from which the data are gathered.
const NumericVector< Number > &	_vector
	A reference to the vector that holds the data that is to be interpolated.
const DofMap &	_dof_map
	Need access to the DofMap of the other system.
const std::vector< unsigned int >	_system_vars
	The indices of the variables within the other system for which data are to be gathered.
std::unique_ptr< PointLocatorBase >	_point_locator
	A point locator is needed to locate the points in the mesh.
std::unique_ptr< std::set< subdomain_id_type > >	_subdomain_ids
	A default set of subdomain ids in which to search for points.
bool	_out_of_mesh_mode
	true if out-of-mesh mode is enabled.
DenseVector< Number >	_out_of_mesh_value
	Value to return outside the mesh if out-of-mesh mode is enabled.
const FunctionBase *	_master
	Const pointer to our master, initialized to nullptr.
bool	_initialized
	When init() was called so that everything is ready for calls to operator() (...), then this bool is true.
bool	_is_time_dependent
	Cache whether or not this function is actually time-dependent.
const Parallel::Communicator &	_communicator

Detailed Description

This class provides function-like objects for data distributed over a mesh.

Author

Daniel Dreyer

Date

2003

Definition at line 54 of file mesh_function.h.

Constructor & Destructor Documentation

MeshFunction() [1/4]

libMesh::MeshFunction::MeshFunction	(	const EquationSystems &	eqn_systems,
		const NumericVector< Number > &	vec,
		const DofMap &	dof_map,
		std::vector< unsigned int >	vars,
		const FunctionBase< Number > *	master = nullptr
	)

Constructor for mesh based functions with vectors as return value.

Optionally takes a master function. If the MeshFunction is to be evaluated outside of the local partition of the mesh, then both the mesh in eqn_systems and the coefficient vector vec should be serialized.

Definition at line 42 of file mesh_function.C.

                                                                 :
  FunctionBase<Number> (master),
  ParallelObject       (eqn_systems),
  _eqn_systems         (eqn_systems),
  _vector              (vec),
  _dof_map             (dof_map),
  _system_vars         (std::move(vars)),
  _out_of_mesh_mode    (false)
{
}

MeshFunction() [2/4]

libMesh::MeshFunction::MeshFunction	(	const EquationSystems &	eqn_systems,
		const NumericVector< Number > &	vec,
		const DofMap &	dof_map,
		const unsigned int	var,
		const FunctionBase< Number > *	master = nullptr
	)

Constructor for mesh based functions with a number as return value.

Optionally takes a master function. If the MeshFunction is to be evaluated outside of the local partition of the mesh, then both the mesh in eqn_systems and the coefficient vector vec should be serialized.

Definition at line 59 of file mesh_function.C.

                                                                 :
  FunctionBase<Number> (master),
  ParallelObject       (eqn_systems),
  _eqn_systems         (eqn_systems),
  _vector              (vec),
  _dof_map             (dof_map),
  _system_vars         (1,var),
  _out_of_mesh_mode    (false)
{
}

MeshFunction() [3/4]

libMesh::MeshFunction::MeshFunction

(

const MeshFunction &

mf

)

A regular copy constructor.

Definition at line 74 of file mesh_function.C.

                                                  :
  FunctionBase<Number> (mf._master),
  ParallelObject       (mf._eqn_systems),
  _eqn_systems         (mf._eqn_systems),
  _vector              (mf._vector),
  _dof_map             (mf._dof_map),
  _system_vars         (mf._system_vars),
  _out_of_mesh_mode    (mf._out_of_mesh_mode)
{
  // Initialize the mf and set the point locator if the
  // input mf had done so.
  if(mf.initialized())
  {
    this->MeshFunction::init();
 
    if(mf.get_point_locator().initialized())
      this->set_point_locator_tolerance(mf.get_point_locator().get_close_to_point_tol());
 
  }
 
  if (mf._subdomain_ids)
    _subdomain_ids =
      std::make_unique<std::set<subdomain_id_type>>
        (*mf._subdomain_ids);
}

References _subdomain_ids, libMesh::PointLocatorBase::get_close_to_point_tol(), get_point_locator(), init(), libMesh::FunctionBase< Output >::initialized(), libMesh::PointLocatorBase::initialized(), and set_point_locator_tolerance().

MeshFunction() [4/4]

libMesh::MeshFunction::MeshFunction ( MeshFunction &&  )

default

Special functions.

• This class contains a unique_ptr so it can't be default copy constructed.
• This class contains const references so it can't be default copy/move assigned.
• The destructor is defaulted out-of-line.

~MeshFunction()

libMesh::MeshFunction::~MeshFunction ( )

default

Destructor.

Member Function Documentation

_gradient_on_elem()

void libMesh::MeshFunction::_gradient_on_elem ( const Point &  p, const Elem *  element, std::vector< Gradient > &  output  )

protected

Helper function for finding a gradient as evaluated from a specific element.

Definition at line 536 of file mesh_function.C.

{
  // resize the output vector to the number of output values
  // that the user told us
  output.resize (this->_system_vars.size());
 
  if (!element)
  {
    libmesh_error_msg_if(!_out_of_mesh_mode,
                         "MeshFunction couldn't find element at p=" <<
                         p << ", but is not in out-of-mesh mode");
    libmesh_assert_equal_to (_out_of_mesh_value.size(),
                             this->_system_vars.size());
    for (auto i : index_range(this->_system_vars))
      output[i] = Gradient(_out_of_mesh_value[i]);
    return;
  }
 
  const unsigned int dim = element->dim();
 
  // Get local coordinates to feed these into compute_data().
  // Note that the fe_type can safely be used from the 0-variable,
  // since the inverse mapping is the same for all FEFamilies
  const Point mapped_point (FEMap::inverse_map (dim, element,
                                                p));
 
  std::vector<Point> point_list (1, mapped_point);
 
  // loop over all vars
  for (auto index : index_range(this->_system_vars))
    {
      // the data for this variable
      const unsigned int var = _system_vars[index];
 
      if (var == libMesh::invalid_uint)
        {
          libmesh_assert (_out_of_mesh_mode &&
                          index < _out_of_mesh_value.size());
          output[index] = Gradient(_out_of_mesh_value(index));
          continue;
        }
 
      const FEType & fe_type = this->_dof_map.variable_type(var);
 
      // where the solution values for the var-th variable are stored
      std::vector<dof_id_type> dof_indices;
      this->_dof_map.dof_indices (element, dof_indices, var);
 
      // interpolate the solution
      Gradient grad(0.);
 
      // for performance-reasons, we use different algorithms now.
      // TODO: Check that both give the same result for finite elements.
      // Otherwive it is wrong...
      if (!element->infinite())
        {
          std::unique_ptr<FEBase> point_fe (FEBase::build(dim, fe_type));
          const std::vector<std::vector<RealGradient>> & dphi = point_fe->get_dphi();
          point_fe->reinit(element, &point_list);
 
          for (auto i : index_range(dof_indices))
            grad.add_scaled(dphi[i][0], this->_vector(dof_indices[i]));
 
        }
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      else
        {
          // Build an FEComputeData that contains both input and output data
          // for the specific compute_data method.
          //
          // TODO: enable this for a vector of points as well...
          FEComputeData data (this->_eqn_systems, mapped_point);
          data.enable_derivative();
          FEInterface::compute_data (dim, fe_type, element, data);
 
          // grad [x] = data.dshape[i](v) * dv/dx  * dof_index [i]
          // sum over all indices
          for (auto i : index_range(dof_indices))
            {
              // local coordinates
              for (std::size_t v=0; v<dim; v++)
                for (std::size_t xyz=0; xyz<LIBMESH_DIM; xyz++)
                  {
                    // FIXME: this needs better syntax: It is matrix-vector multiplication.
                    grad(xyz) += data.local_transform[v][xyz]
                      * data.dshape[i](v)
                      * this->_vector(dof_indices[i]);
                  }
            }
        }
#endif
      output[index] = grad;
    }
}

References _dof_map, _eqn_systems, _out_of_mesh_mode, _out_of_mesh_value, _system_vars, _vector, libMesh::TypeVector< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::FEInterface::compute_data(), dim, libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), libMesh::FEComputeData::dshape, libMesh::FEComputeData::enable_derivative(), libMesh::index_range(), libMesh::Elem::infinite(), libMesh::invalid_uint, libMesh::FEMap::inverse_map(), libMesh::libmesh_assert(), libMesh::FEComputeData::local_transform, libMesh::DenseVector< T >::size(), and libMesh::DofMap::variable_type().

Referenced by discontinuous_gradient(), and gradient().

check_found_elem()

const Elem * libMesh::MeshFunction::check_found_elem ( const Elem *  element, const Point &  p  ) const

protected

Helper function that is called by MeshFunction::find_element() and MeshFunction::find_elements() to ensure that Elems found by the PointLocator are actually "evaluable" on the processor where they are found.

Definition at line 784 of file mesh_function.C.

{
  // If the PointLocator did not find an Element containing Point p,
  // OR if the PointLocator found a local element containting Point p,
  // we can simply return it.
  if (!element || (element->processor_id() == this->processor_id()))
    return element;
 
  // Otherwise, the PointLocator returned a valid but non-local
  // element.  Therefore, we have to do some further checks:
  //
  // 1.) If we have a SERIAL _vector, then we can just return the
  //     non-local element, because all the DOFs are available.
  if (_vector.type() == SERIAL)
    return element;
 
  // 2.) If we have a GHOSTED _vector, then we can return a non-local
  //     Element provided that all of its DOFs are ghosted on this
  //     processor. That should be faster than the other option, which
  //     is to search through all the Elem's point_neighbors() for a
  //     suitable local Elem.
  if (_vector.type() == GHOSTED && _dof_map.is_evaluable(*element))
    return element;
 
  // 3.) If we have a PARALLEL vector, then we search the non-local
  //     Elem's point neighbors for a local one to return instead. If
  //     we don't eventually find one, we just return nullptr.
  std::set<const Elem *> point_neighbors;
  element->find_point_neighbors(p, point_neighbors);
  element = nullptr;
  for (const auto & elem : point_neighbors)
    if (elem->processor_id() == this->processor_id())
      {
        element = elem;
        break;
      }
 
  return element;
}

References _dof_map, _vector, libMesh::Elem::find_point_neighbors(), libMesh::GHOSTED, libMesh::DofMap::is_evaluable(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::SERIAL, and libMesh::NumericVector< T >::type().

Referenced by find_element().

clear()

void libMesh::MeshFunction::clear ( )

overridevirtual

Clears the function.

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 128 of file mesh_function.C.

{
  // only delete the point locator when we are the master
  if (_point_locator && !_master)
    _point_locator.reset();
 
  this->_initialized = false;
}

References libMesh::FunctionBase< Number >::_initialized, libMesh::FunctionBase< Number >::_master, and _point_locator.

clone()

std::unique_ptr< FunctionBase< Number > > libMesh::MeshFunction::clone ( ) const

overridevirtual

Returns

A new copy of the function.

The new copy uses the original as a master function to enable simultaneous evaluations of the copies in different threads.

Note

This implies the copy should not be used after the original is destroyed.

Implements libMesh::FunctionBase< Number >.

Definition at line 139 of file mesh_function.C.

{
  return std::make_unique<MeshFunction>(*this);
}

comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

component()

Number libMesh::FunctionBase< Number >::component ( unsigned int  i, const Point &  p, Real  time = 0.  )

inlinevirtualinherited

Returns

The vector component i at coordinate p and time time.

Note

Subclasses aren't required to override this, since the default implementation is based on the full vector evaluation, which is often correct.

Subclasses are recommended to override this, since the default implementation is based on a vector evaluation, which is usually unnecessarily inefficient.

The default implementation calls operator() with a DenseVector of size i+1 which will result in unexpected behaviour if operator() makes any access beyond that limit.

Reimplemented in SolutionFunction< dim >, SolutionFunction< dim >, SolutionFunction< dim >, SolutionFunction< dim >, SolutionFunction< dim >, SolutionFunction< dim >, SolutionFunction< dim >, PeriodicQuadFunction, and TripleFunction.

Definition at line 145 of file function_base.h.

{
  DenseVector<Output> outvec(i+1);
  (*this)(p, time, outvec);
  return outvec(i);
}

disable_out_of_mesh_mode()

void libMesh::MeshFunction::disable_out_of_mesh_mode

(

)

Disables out-of-mesh mode.

This is also the default.

Definition at line 851 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
  _point_locator->disable_out_of_mesh_mode();
  _out_of_mesh_mode = false;
}

References _out_of_mesh_mode, _point_locator, libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

discontinuous_gradient() [1/3]

void libMesh::MeshFunction::discontinuous_gradient	(	const Point &	p,
		const Real	time,
		std::map< const Elem *, std::vector< Gradient > > &	output
	)

Similar to gradient, but with the difference that multiple values on faces are explicitly permitted.

This is useful for evaluating gradients on faces where the values to the left and right are different.

Definition at line 498 of file mesh_function.C.

{
  this->discontinuous_gradient (p, time, output, this->_subdomain_ids.get());
}

References _subdomain_ids, and discontinuous_gradient().

discontinuous_gradient() [2/3]

void libMesh::MeshFunction::discontinuous_gradient	(	const Point &	p,
		const Real	time,
		std::map< const Elem *, std::vector< Gradient > > &	output,
		const std::set< subdomain_id_type > *	subdomain_ids
	)

Similar to gradient, but with the difference that multiple values on faces are explicitly permitted.

This is useful for evaluating gradients on faces where the values to the left and right are different.

Definition at line 507 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  // clear the output map
  output.clear();
 
  // get the candidate elements
  std::set<const Elem *> candidate_element = this->find_elements(p,subdomain_ids);
 
  // loop through all candidates, if the set is empty this function will return an
  // empty map
  for (const auto & element : candidate_element)
    {
      // define a temporary vector to store all values
      std::vector<Gradient> temp_output (cast_int<unsigned int>(this->_system_vars.size()));
 
      this->_gradient_on_elem(p, element, temp_output);
 
      // Insert temp_output into output
      output.emplace(element, std::move(temp_output));
    }
}

References _gradient_on_elem(), _system_vars, find_elements(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

discontinuous_gradient() [3/3]

std::map< const Elem *, Gradient > libMesh::MeshFunction::discontinuous_gradient	(	const Point &	p,
		const Real	time = 0.
	)

Returns

A map of first derivatives (gradients) of variable 0 at point p and for time. map is from element to Gradient and accounts for double defined values on faces if the gradient is discontinuous

Definition at line 181 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  std::map<const Elem *, std::vector<Gradient>> buffer;
  this->discontinuous_gradient (p, time, buffer);
  std::map<const Elem *, Gradient> return_value;
  for (const auto & [elem, vec] : buffer)
    return_value[elem] = vec[0];
  // NOTE: If no suitable element is found, then the map return_value is empty. This
  // puts burden on the user of this function but I don't really see a better way.
  return return_value;
}

References discontinuous_gradient(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by discontinuous_gradient(), discontinuous_gradient(), and MeshfunctionDFEM::test_mesh_function_dfem_grad().

discontinuous_value() [1/3]

void libMesh::MeshFunction::discontinuous_value	(	const Point &	p,
		const Real	time,
		std::map< const Elem *, DenseVector< Number > > &	output
	)

Similar to operator() with the same parameter list, but with the difference that multiple values on faces are explicitly permitted.

This is useful for discontinuous shape functions that are evaluated on faces.

Definition at line 382 of file mesh_function.C.

{
  this->discontinuous_value (p, time, output, this->_subdomain_ids.get());
}

References _subdomain_ids, and discontinuous_value().

discontinuous_value() [2/3]

void libMesh::MeshFunction::discontinuous_value	(	const Point &	p,
		const Real	time,
		std::map< const Elem *, DenseVector< Number > > &	output,
		const std::set< subdomain_id_type > *	subdomain_ids
	)

Similar to operator() with the same parameter list, but with the difference that multiple values on faces are explicitly permitted.

This is useful for discontinuous shape functions that are evaluated on faces.

Definition at line 391 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  // clear the output map
  output.clear();
 
  // get the candidate elements
  std::set<const Elem *> candidate_element = this->find_elements(p,subdomain_ids);
 
  // loop through all candidates, if the set is empty this function will return an
  // empty map
  for (const auto & element : candidate_element)
    {
      if (!element)
        {
          // We'd better be in out_of_mesh_mode if we couldn't find an
          // element in the mesh
          libmesh_assert (_out_of_mesh_mode);
          output[element] = _out_of_mesh_value;
          continue;
        }
 
      const unsigned int dim = element->dim();
 
      // define a temporary vector to store all values
      DenseVector<Number> temp_output (cast_int<unsigned int>(this->_system_vars.size()));
 
      // Get local coordinates to feed these into compute_data().
      // Note that the fe_type can safely be used from the 0-variable,
      // since the inverse mapping is the same for all FEFamilies
      const Point mapped_point (FEMap::inverse_map (dim, element, p));
 
      // loop over all vars
      for (auto index : index_range(this->_system_vars))
        {
          // the data for this variable
          const unsigned int var = _system_vars[index];
 
          if (var == libMesh::invalid_uint)
            {
              libmesh_assert (_out_of_mesh_mode &&
                              index < _out_of_mesh_value.size());
              temp_output(index) = _out_of_mesh_value(index);
              continue;
            }
 
          const FEType & fe_type = this->_dof_map.variable_type(var);
 
          // Build an FEComputeData that contains both input and output data
          // for the specific compute_data method.
          {
            FEComputeData data (this->_eqn_systems, mapped_point);
 
            FEInterface::compute_data (dim, fe_type, element, data);
 
            // where the solution values for the var-th variable are stored
            std::vector<dof_id_type> dof_indices;
            this->_dof_map.dof_indices (element, dof_indices, var);
 
            // interpolate the solution
            {
              Number value = 0.;
 
              for (auto i : index_range(dof_indices))
                value += this->_vector(dof_indices[i]) * data.shape[i];
 
              temp_output(index) = value;
            }
 
          }
 
          // next variable
        }
 
      // Insert temp_output into output
      output[element] = temp_output;
    }
}

References _dof_map, _eqn_systems, _out_of_mesh_mode, _out_of_mesh_value, _system_vars, _vector, libMesh::FEInterface::compute_data(), dim, libMesh::DofMap::dof_indices(), find_elements(), libMesh::index_range(), libMesh::FunctionBase< Number >::initialized(), libMesh::invalid_uint, libMesh::FEMap::inverse_map(), libMesh::libmesh_assert(), libMesh::FEComputeData::shape, libMesh::DenseVector< T >::size(), value, and libMesh::DofMap::variable_type().

discontinuous_value() [3/3]

std::map< const Elem *, Number > libMesh::MeshFunction::discontinuous_value	(	const Point &	p,
		const Real	time = 0.
	)

Returns

A map of values of variable 0 at point p and for time.

The std::map is from element to Number and accounts for doubly-defined values on faces if discontinuous variables are used.

Definition at line 156 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  std::map<const Elem *, DenseVector<Number>> buffer;
  this->discontinuous_value (p, time, buffer);
  std::map<const Elem *, Number> return_value;
  for (const auto & [elem, vec] : buffer)
    return_value[elem] = vec(0);
  // NOTE: If no suitable element is found, then the map return_value is empty. This
  // puts burden on the user of this function but I don't really see a better way.
  return return_value;
}

References discontinuous_value(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by discontinuous_value(), discontinuous_value(), and MeshfunctionDFEM::test_mesh_function_dfem().

enable_out_of_mesh_mode() [1/2]

void libMesh::MeshFunction::enable_out_of_mesh_mode

(

const DenseVector< Number > &

value

)

Enables out-of-mesh mode.

In this mode, if asked for a point that is not contained in any element, the MeshFunction will return the given value instead of crashing. This mode is off per default. If you use a master mesh function and you want to enable this mode, you will have to enable it for the master mesh function as well and for all mesh functions that have the same master mesh function. You may, however, specify different values.

Definition at line 836 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
  _point_locator->enable_out_of_mesh_mode();
  _out_of_mesh_mode = true;
  _out_of_mesh_value = value;
}

References _out_of_mesh_mode, _out_of_mesh_value, _point_locator, libMesh::FunctionBase< Number >::initialized(), libMesh::libmesh_assert(), and value.

Referenced by enable_out_of_mesh_mode(), main(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), and MeshFunctionTest::test_subdomain_id_sets().

enable_out_of_mesh_mode() [2/2]

void libMesh::MeshFunction::enable_out_of_mesh_mode

(

const Number &

value

)

Enables out-of-mesh mode.

In this mode, if asked for a point that is not contained in any element, the MeshFunction will return the given value instead of crashing. This mode is off per default. If you use a master mesh function and you want to enable this mode, you will have to enable it for the master mesh function as well and for all mesh functions that have the same master mesh function. You may, however, specify different values.

Definition at line 844 of file mesh_function.C.

{
  DenseVector<Number> v(1);
  v(0) = value;
  this->enable_out_of_mesh_mode(v);
}

References enable_out_of_mesh_mode(), and value.

find_element()

const Elem * libMesh::MeshFunction::find_element ( const Point &  p, const std::set< subdomain_id_type > *  subdomain_ids = nullptr  ) const

protected

Helper function to reduce code duplication.

Definition at line 725 of file mesh_function.C.

{
  // Ensure that in the case of a master mesh function, the
  // out-of-mesh mode is enabled either for both or for none.  This is
  // important because the out-of-mesh mode is also communicated to
  // the point locator.  Since this is time consuming, enable it only
  // in debug mode.
#ifdef DEBUG
  if (this->_master != nullptr)
    {
      const MeshFunction * master =
        cast_ptr<const MeshFunction *>(this->_master);
      libmesh_error_msg_if(_out_of_mesh_mode!=master->_out_of_mesh_mode,
                           "ERROR: If you use out-of-mesh-mode in connection with master mesh "
                           "functions, you must enable out-of-mesh mode for both the master and the slave mesh function.");
    }
#endif
 
  // locate the point in the other mesh
  const Elem * element = (*_point_locator)(p, subdomain_ids);
 
  // Make sure that the element found is evaluable
  return this->check_found_elem(element, p);
}

References libMesh::FunctionBase< Number >::_master, _out_of_mesh_mode, and check_found_elem().

Referenced by gradient(), hessian(), and operator()().

find_elements()

std::set< const Elem * > libMesh::MeshFunction::find_elements ( const Point &  p, const std::set< subdomain_id_type > *  subdomain_ids = nullptr  ) const

protected

Returns

All elements that are close to a point p.

This is similar to find_element() but covers cases where p is on the boundary.

Definition at line 751 of file mesh_function.C.

{
  // Ensure that in the case of a master mesh function, the
  // out-of-mesh mode is enabled either for both or for none.  This is
  // important because the out-of-mesh mode is also communicated to
  // the point locator.  Since this is time consuming, enable it only
  // in debug mode.
#ifdef DEBUG
  if (this->_master != nullptr)
    {
      const MeshFunction * master =
        cast_ptr<const MeshFunction *>(this->_master);
      libmesh_error_msg_if(_out_of_mesh_mode!=master->_out_of_mesh_mode,
                           "ERROR: If you use out-of-mesh-mode in connection with master mesh "
                           "functions, you must enable out-of-mesh mode for both the master and the slave mesh function.");
    }
#endif
 
  // locate the point in the other mesh
  std::set<const Elem *> candidate_elements;
  std::set<const Elem *> final_candidate_elements;
  (*_point_locator)(p, candidate_elements, subdomain_ids);
 
  // For each candidate Elem, if it is evaluable, add it to the set of
  // final candidate Elems.
  for (const auto & element : candidate_elements)
    final_candidate_elements.insert(this->check_found_elem(element, p));
 
  return final_candidate_elements;
}

References libMesh::FunctionBase< Number >::_master, and _out_of_mesh_mode.

Referenced by discontinuous_gradient(), and discontinuous_value().

get_point_locator() [1/2]

PointLocatorBase & libMesh::MeshFunction::get_point_locator

(

)

Definition at line 830 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
  return *_point_locator;
}

References _point_locator, libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

get_point_locator() [2/2]

const PointLocatorBase & libMesh::MeshFunction::get_point_locator

(

)

const

Returns

The current PointLocator object, for use elsewhere.

Note

The MeshFunction object must be initialized before this is called.

Definition at line 824 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
  return *_point_locator;
}

References _point_locator, libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by MeshFunction().

gradient() [1/3]

void libMesh::MeshFunction::gradient	(	const Point &	p,
		const Real	time,
		std::vector< Gradient > &	output
	)

Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.

Definition at line 476 of file mesh_function.C.

{
  this->gradient(p, time, output, this->_subdomain_ids.get());
}

References _subdomain_ids, and gradient().

gradient() [2/3]

void libMesh::MeshFunction::gradient	(	const Point &	p,
		const Real	time,
		std::vector< Gradient > &	output,
		const std::set< subdomain_id_type > *	subdomain_ids
	)

Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids, which parameter overrides the internal subdomain_ids.

Definition at line 485 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  const Elem * element = this->find_element(p,subdomain_ids);
 
  this->_gradient_on_elem(p, element, output);
}

References _gradient_on_elem(), find_element(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

gradient() [3/3]

Gradient libMesh::MeshFunction::gradient	(	const Point &	p,
		const Real	time = 0.
	)

Returns

The first derivatives of variable 0 at point p and for time, which defaults to zero.

Definition at line 171 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  std::vector<Gradient> buf (1);
  this->gradient(p, time, buf);
  return buf[0];
}

References gradient(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error(), gptr(), gradient(), gradient(), and MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value().

hessian() [1/3]

void libMesh::MeshFunction::hessian	(	const Point &	p,
		const Real	time,
		std::vector< Tensor > &	output
	)

Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.

Definition at line 635 of file mesh_function.C.

{
  this->hessian(p, time, output, this->_subdomain_ids.get());
}

References _subdomain_ids, and hessian().

hessian() [2/3]

void libMesh::MeshFunction::hessian	(	const Point &	p,
		const Real	time,
		std::vector< Tensor > &	output,
		const std::set< subdomain_id_type > *	subdomain_ids
	)

Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids.

This is useful in cases where there are multiple dimensioned elements, for example.

Definition at line 644 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  // resize the output vector to the number of output values
  // that the user told us
  output.resize (this->_system_vars.size());
 
  const Elem * element = this->find_element(p,subdomain_ids);
 
  if (!element)
    {
      libmesh_error_msg_if(!_out_of_mesh_mode,
                           "MeshFunction couldn't find element at p=" <<
                           p << ", but is not in out-of-mesh mode");
      libmesh_assert_equal_to (_out_of_mesh_value.size(),
                               this->_system_vars.size());
      for (auto i : index_range(this->_system_vars))
        output[i] = Tensor(_out_of_mesh_value[i]);
      return;
    }
  else
    {
      if(element->infinite())
        libmesh_warning("Warning: Requested the Hessian of an Infinite element."
                        << "Second derivatives for Infinite elements"
                        << " are not yet implemented!"
                        << std::endl);
 
      {
        const unsigned int dim = element->dim();
 
 
        // Get local coordinates to feed these into compute_data().
        // Note that the fe_type can safely be used from the 0-variable,
        // since the inverse mapping is the same for all FEFamilies
        const Point mapped_point (FEMap::inverse_map (dim, element,
                                                      p));
 
        std::vector<Point> point_list (1, mapped_point);
 
        // loop over all vars
        for (auto index : index_range(this->_system_vars))
          {
            // the data for this variable
            const unsigned int var = _system_vars[index];
 
            if (var == libMesh::invalid_uint)
              {
                libmesh_assert (_out_of_mesh_mode &&
                                index < _out_of_mesh_value.size());
                output[index] = Tensor(_out_of_mesh_value(index));
                continue;
              }
            const FEType & fe_type = this->_dof_map.variable_type(var);
 
            std::unique_ptr<FEBase> point_fe (FEBase::build(dim, fe_type));
            const std::vector<std::vector<RealTensor>> & d2phi =
              point_fe->get_d2phi();
            point_fe->reinit(element, &point_list);
 
            // where the solution values for the var-th variable are stored
            std::vector<dof_id_type> dof_indices;
            this->_dof_map.dof_indices (element, dof_indices, var);
 
            // interpolate the solution
            Tensor hess;
 
            for (auto i : index_range(dof_indices))
              hess.add_scaled(d2phi[i][0], this->_vector(dof_indices[i]));
 
            output[index] = hess;
          }
      }
    }
}

References _dof_map, _out_of_mesh_mode, _out_of_mesh_value, _system_vars, libMesh::TypeTensor< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), dim, libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), find_element(), libMesh::index_range(), libMesh::Elem::infinite(), libMesh::FunctionBase< Number >::initialized(), libMesh::invalid_uint, libMesh::FEMap::inverse_map(), libMesh::libmesh_assert(), libMesh::DenseVector< T >::size(), and libMesh::DofMap::variable_type().

hessian() [3/3]

Tensor libMesh::MeshFunction::hessian	(	const Point &	p,
		const Real	time = 0.
	)

Returns

The second derivatives of variable 0 at point p and for time, which defaults to zero.

Definition at line 197 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  std::vector<Tensor> buf (1);
  this->hessian(p, time, buf);
  return buf[0];
}

References hessian(), libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error(), hessian(), hessian(), and MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value().

init()

void libMesh::MeshFunction::init ( )

overridevirtual

Override the FunctionBase::init() member function.

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 104 of file mesh_function.C.

{
  // are indices of the desired variable(s) provided?
  libmesh_assert_greater (this->_system_vars.size(), 0);
 
  // Don't do twice...
  if (this->_initialized)
    {
      libmesh_assert(_point_locator);
      return;
    }
 
  // The Mesh owns the "master" PointLocator, while handing us a
  // PointLocator "proxy" that forwards all requests to the master.
  const MeshBase & mesh = this->_eqn_systems.get_mesh();
  _point_locator = mesh.sub_point_locator();
 
  // ready for use
  this->_initialized = true;
}

References _eqn_systems, libMesh::FunctionBase< Number >::_initialized, _point_locator, _system_vars, libMesh::EquationSystems::get_mesh(), libMesh::libmesh_assert(), mesh, and libMesh::MeshBase::sub_point_locator().

Referenced by main(), MeshFunction(), libMesh::InterMeshProjection::project_system_vectors(), MeshFunctionTest::read_variable_info_from_output_data(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_subdomain_id_sets(), SystemsTest::testProjectCubeWithMeshFunction(), and libMesh::MeshFunctionSolutionTransfer::transfer().

initialized()

bool libMesh::FunctionBase< Number >::initialized ( ) const

inlineinherited

Returns

true when this object is properly initialized and ready for use, false otherwise.

Definition at line 154 of file function_base.h.

{
  return (this->_initialized);
}

is_time_dependent()

bool libMesh::FunctionBase< Number >::is_time_dependent ( ) const

inlineinherited

Returns

true when the function this object represents is actually time-dependent, false otherwise.

Definition at line 168 of file function_base.h.

{
  return (this->_is_time_dependent);
}

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

operator()() [1/4]

void libMesh::MeshFunction::operator() ( const Point &  p, const Real  time, DenseVector< Number > &  output  )

overridevirtual

Computes values at coordinate p and for time time, which defaults to zero, optionally restricting the point to the MeshFunction subdomain_ids.

This is useful in cases where there are multiple dimensioned elements, for example.

Implements libMesh::FunctionBase< Number >.

Definition at line 208 of file mesh_function.C.

{
  this->operator() (p, time, output, this->_subdomain_ids.get());
}

References _subdomain_ids, and operator()().

operator()() [2/4]

void libMesh::MeshFunction::operator()	(	const Point &	p,
		const Real	time,
		DenseVector< Number > &	output,
		const std::set< subdomain_id_type > *	subdomain_ids
	)

Computes values at coordinate p and for time time, restricting the point to the passed subdomain_ids, which parameter overrides the internal subdomain_ids.

Definition at line 215 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  const Elem * element = this->find_element(p,subdomain_ids);
 
  if (!element)
    {
      // We'd better be in out_of_mesh_mode if we couldn't find an
      // element in the mesh
      libmesh_assert (_out_of_mesh_mode);
      output = _out_of_mesh_value;
    }
  else
    {
      {
        const unsigned int dim = element->dim();
 
 
        // Get local coordinates to feed these into compute_data().
        // Note that the fe_type can safely be used from the 0-variable,
        // since the inverse mapping is the same for all FEFamilies
        const Point mapped_point (FEMap::inverse_map (dim, element,
                                                      p));
 
        // resize the output vector to the number of output values
        // that the user told us, this include multiple entries for
        // the spatial components of vector variable
        unsigned int output_size = 0;
        for (auto index : index_range(this->_system_vars))
          {
            const unsigned int var = _system_vars[index];
 
            if (var == libMesh::invalid_uint)
              {
                libmesh_assert (_out_of_mesh_mode &&
                                index < _out_of_mesh_value.size());
                output(index) = _out_of_mesh_value(index);
                continue;
              }
 
            const FEType & fe_type = this->_dof_map.variable_type(var);
 
            // Adding entries for each scalar variable and spatial components of
            // vector variables
            switch (fe_type.family)
              {
              case HIERARCHIC_VEC:
              case L2_HIERARCHIC_VEC:
              case LAGRANGE_VEC:
              case L2_LAGRANGE_VEC:
              case MONOMIAL_VEC:
              case NEDELEC_ONE:
              case RAVIART_THOMAS:
              case L2_RAVIART_THOMAS:
                {
                  output_size = output_size + dim;
                  break;
                }
              default:
                {
                  output_size++;
                  break;
                }
              }
 
          }
        output.resize(output_size);
 
        // Adding a counter to keep the output indexing correct for mix scalar-vector output sets
        unsigned int vec_count = 0;
 
        // loop over all vars
        for (auto index : index_range(this->_system_vars))
          {
            // the data for this variable
            const unsigned int var = _system_vars[index];
 
            if (var == libMesh::invalid_uint)
              {
                libmesh_assert (_out_of_mesh_mode &&
                                index < _out_of_mesh_value.size());
                output(index) = _out_of_mesh_value(index);
                continue;
              }
 
            const FEType & fe_type = this->_dof_map.variable_type(var);
 
            // The method between vector and scalar variable are different:
            // For scalar variables, we use the previous established method of using FEInterface::compute_data
            // For vector variables, we call the phi() data directly to build the variable solution
            switch (fe_type.family)
              {
              case HIERARCHIC_VEC:
              case L2_HIERARCHIC_VEC:
              case LAGRANGE_VEC:
              case L2_LAGRANGE_VEC:
              case MONOMIAL_VEC:
              case NEDELEC_ONE:
              case RAVIART_THOMAS:
              case L2_RAVIART_THOMAS:
                {
                  // Calling the physical mesh point needed for the shape function
                  FEComputeData data (this->_eqn_systems, mapped_point);
                  const Point & pt = data.p;
 
                  // where the solution values for the var-th variable are stored
                  std::vector<dof_id_type> dof_indices;
                  this->_dof_map.dof_indices (element, dof_indices, var);
 
                  // Calling the properly-transformed shape function using get_phi()
                  std::unique_ptr<FEVectorBase> vec_fe = FEVectorBase::build(dim, fe_type);
                  std::vector<Point> vec_pt = {pt};
                  const std::vector<std::vector<RealGradient>> & vec_phi = vec_fe->get_phi();
                  vec_fe->reinit(element, &vec_pt);
 
                  // interpolate the solution
                  {
                    for (unsigned int d = 0; d < dim; d++)
                    {
                      Number value = 0.;
 
                      for (auto i : index_range(dof_indices))
                        value += this->_vector(dof_indices[i]) * (vec_phi[i][0](d));
 
                      output(index+vec_count*(dim-1)+d) = value;
                    }
                  }
 
                  vec_count++;
                  break;
                }
              default:
                {
                  // Build an FEComputeData that contains both input and output data
                  // for the specific compute_data method.
 
                  FEComputeData data (this->_eqn_systems, mapped_point);
 
                  FEInterface::compute_data (dim, fe_type, element, data);
 
                  // where the solution values for the var-th variable are stored
                  std::vector<dof_id_type> dof_indices;
                  this->_dof_map.dof_indices (element, dof_indices, var);
 
                  // interpolate the solution
                  {
                    Number value = 0.;
 
                    for (auto i : index_range(dof_indices))
                      value += this->_vector(dof_indices[i]) * data.shape[i];
 
                    output(index+vec_count*(dim-1)) = value;
                  }
                  break;
                }
              }
 
            // next variable
          }
      }
    }
}

References _dof_map, _eqn_systems, _out_of_mesh_mode, _out_of_mesh_value, _system_vars, _vector, libMesh::FEGenericBase< OutputType >::build(), libMesh::FEInterface::compute_data(), dim, libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), libMesh::FEType::family, find_element(), libMesh::HIERARCHIC_VEC, libMesh::index_range(), libMesh::FunctionBase< Number >::initialized(), libMesh::invalid_uint, libMesh::FEMap::inverse_map(), libMesh::L2_HIERARCHIC_VEC, libMesh::L2_LAGRANGE_VEC, libMesh::L2_RAVIART_THOMAS, libMesh::LAGRANGE_VEC, libMesh::libmesh_assert(), libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::FEComputeData::p, libMesh::RAVIART_THOMAS, libMesh::DenseVector< T >::resize(), libMesh::FEComputeData::shape, libMesh::DenseVector< T >::size(), value, and libMesh::DofMap::variable_type().

operator()() [3/4]

Number libMesh::MeshFunction::operator() ( const Point &  p, const Real  time = 0.  )

overridevirtual

Returns

The value of variable 0 at point p and for time, which defaults to zero.

Implements libMesh::FunctionBase< Number >.

Definition at line 146 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  DenseVector<Number> buf (1);
  this->operator() (p, time, buf);
  return buf(0);
}

References libMesh::FunctionBase< Number >::initialized(), libMesh::libmesh_assert(), and operator()().

Referenced by operator()(), and operator()().

operator()() [4/4]

void libMesh::FunctionBase< Number >::operator() ( const Point &  p, DenseVector< Number > &  output  )

inlineinherited

Evaluation function for time-independent vector-valued functions.

Sets output values in the passed-in output DenseVector.

Definition at line 116 of file function_base.h.

{
  // Call the time-dependent function with t=0.
  this->operator()(p, 0., output);
}

operator=() [1/2]

MeshFunction & libMesh::MeshFunction::operator= ( const MeshFunction &  )

delete

operator=() [2/2]

MeshFunction & libMesh::MeshFunction::operator= ( MeshFunction &&  )

delete

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

  { return cast_int<processor_id_type>(_communicator.rank()); }

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

set_is_time_dependent()

void libMesh::FunctionBase< Number >::set_is_time_dependent ( bool  is_time_dependent )

inlineinherited

Function to set whether this is a time-dependent function or not.

This is intended to be only used by subclasses who cannot natively determine time-dependence. In such a case, this function should be used immediately following construction.

Definition at line 162 of file function_base.h.

{
  this->_is_time_dependent = is_time_dependent;
}

set_point_locator_tolerance()

void libMesh::MeshFunction::set_point_locator_tolerance

(

Real

tol

)

We may want to specify a tolerance for the PointLocator to use, since in some cases the point we want to evaluate at might be slightly outside the mesh (due to numerical rounding issues, for example).

Definition at line 858 of file mesh_function.C.

{
  _point_locator->set_close_to_point_tol(tol);
  _point_locator->set_contains_point_tol(tol);
}

References _point_locator.

Referenced by MeshFunction().

set_subdomain_ids()

void libMesh::MeshFunction::set_subdomain_ids

(

const std::set< subdomain_id_type > *

subdomain_ids

)

Choose a default list of subdomain ids to be searched for points.

If the provided list pointer is null or if no list has been provided, then all subdomain ids are searched. This list can be overridden on a per-evaluation basis by using the method overrides with a similar argument.

Definition at line 869 of file mesh_function.C.

{
  if (subdomain_ids)
    _subdomain_ids = std::make_unique<std::set<subdomain_id_type>>(*subdomain_ids);
  else
    _subdomain_ids.reset();
}

References _subdomain_ids.

Referenced by MeshFunctionTest::test_subdomain_id_sets().

unset_point_locator_tolerance()

void libMesh::MeshFunction::unset_point_locator_tolerance

(

)

Turn off the user-specified PointLocator tolerance.

Definition at line 864 of file mesh_function.C.

{
  _point_locator->unset_close_to_point_tol();
}

References _point_locator.

Member Data Documentation

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_dof_map

const DofMap& libMesh::MeshFunction::_dof_map

protected

Need access to the DofMap of the other system.

Definition at line 377 of file mesh_function.h.

Referenced by _gradient_on_elem(), check_found_elem(), discontinuous_value(), hessian(), and operator()().

_eqn_systems

const EquationSystems& libMesh::MeshFunction::_eqn_systems

protected

The equation systems handler, from which the data are gathered.

Definition at line 366 of file mesh_function.h.

Referenced by _gradient_on_elem(), discontinuous_value(), init(), and operator()().

_initialized

bool libMesh::FunctionBase< Number >::_initialized

protectedinherited

When init() was called so that everything is ready for calls to operator() (...), then this bool is true.

Definition at line 184 of file function_base.h.

_is_time_dependent

bool libMesh::FunctionBase< Number >::_is_time_dependent

protectedinherited

Cache whether or not this function is actually time-dependent.

Definition at line 189 of file function_base.h.

_master

const FunctionBase* libMesh::FunctionBase< Number >::_master

protectedinherited

Const pointer to our master, initialized to nullptr.

There may be cases where multiple functions are required, but to save memory, one master handles some centralized data.

Definition at line 178 of file function_base.h.

_out_of_mesh_mode

bool libMesh::MeshFunction::_out_of_mesh_mode

protected

true if out-of-mesh mode is enabled.

See enable_out_of_mesh_mode() for more details. Default is false.

Definition at line 400 of file mesh_function.h.

Referenced by _gradient_on_elem(), disable_out_of_mesh_mode(), discontinuous_value(), enable_out_of_mesh_mode(), find_element(), find_elements(), hessian(), and operator()().

_out_of_mesh_value

DenseVector<Number> libMesh::MeshFunction::_out_of_mesh_value

protected

Value to return outside the mesh if out-of-mesh mode is enabled.

See enable_out_of_mesh_mode() for more details.

Definition at line 406 of file mesh_function.h.

Referenced by _gradient_on_elem(), discontinuous_value(), enable_out_of_mesh_mode(), hessian(), and operator()().

_point_locator

std::unique_ptr<PointLocatorBase> libMesh::MeshFunction::_point_locator

protected

A point locator is needed to locate the points in the mesh.

Definition at line 389 of file mesh_function.h.

Referenced by clear(), disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), get_point_locator(), get_point_locator(), init(), set_point_locator_tolerance(), and unset_point_locator_tolerance().

_subdomain_ids

std::unique_ptr<std::set<subdomain_id_type> > libMesh::MeshFunction::_subdomain_ids

protected

A default set of subdomain ids in which to search for points.

Definition at line 394 of file mesh_function.h.

Referenced by discontinuous_gradient(), discontinuous_value(), gradient(), hessian(), MeshFunction(), operator()(), and set_subdomain_ids().

_system_vars

const std::vector<unsigned int> libMesh::MeshFunction::_system_vars

protected

The indices of the variables within the other system for which data are to be gathered.

Definition at line 383 of file mesh_function.h.

Referenced by _gradient_on_elem(), discontinuous_gradient(), discontinuous_value(), hessian(), init(), and operator()().

_vector

const NumericVector<Number>& libMesh::MeshFunction::_vector

protected

A reference to the vector that holds the data that is to be interpolated.

Definition at line 372 of file mesh_function.h.

Referenced by _gradient_on_elem(), check_found_elem(), discontinuous_value(), and operator()().

---

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

• include/mesh/mesh_function.h
• src/mesh/mesh_function.C