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, const std::vector< unsigned int > &vars, const FunctionBase< Number > *master=nullptr)
	Constructor for mesh based functions with vectors as return value. More...
	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. More...
	MeshFunction (MeshFunction &&)=delete
	This class is sometimes responsible for cleaning up the _point_locator, so it can't be default (shallow) copy constructed or move constructed. More...
	MeshFunction (const MeshFunction &)=delete
MeshFunction &	operator= (const MeshFunction &)=delete
	This class contains const references so it can't be assigned. More...
MeshFunction &	operator= (MeshFunction &&)=delete
	~MeshFunction ()
	Destructor. More...
virtual void	init () override
	Override the FunctionBase::init() member function by calling our own and specifying the Trees::NODES method. More...
void	init (const Trees::BuildType point_locator_build_type)
	The actual initialization process. More...
virtual void	clear () override
	Clears the function. More...
virtual std::unique_ptr< FunctionBase< Number > >	clone () const override
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.)
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 passed subdomain_ids. More...
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. More...
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. More...
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. More...
void	gradient (const Point &p, const Real time, std::vector< Gradient > &output, const std::set< subdomain_id_type > *subdomain_ids=nullptr)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids. More...
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. More...
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. More...
void	hessian (const Point &p, const Real time, std::vector< Tensor > &output, const std::set< subdomain_id_type > *subdomain_ids=nullptr)
	Computes gradients at coordinate p and for time time, which defaults to zero, optionally restricting the point to the passed subdomain_ids. More...
const PointLocatorBase &	get_point_locator (void) const
void	enable_out_of_mesh_mode (const DenseVector< Number > &value)
	Enables out-of-mesh mode. More...
void	enable_out_of_mesh_mode (const Number &value)
	Enables out-of-mesh mode. More...
void	disable_out_of_mesh_mode (void)
	Disables out-of-mesh mode. More...
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). More...
void	unset_point_locator_tolerance ()
	Turn off the user-specified PointLocator tolerance. More...
void	operator() (const Point &p, DenseVector< Number > &output)
	Evaluation function for time-independent vector-valued functions. More...
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. More...
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. More...
std::set< const Elem * >	find_elements (const Point &p, const std::set< subdomain_id_type > *subdomain_ids=nullptr) const

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

Referenced by clone().

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 61 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),
  _point_locator       (nullptr),
  _out_of_mesh_mode    (false),
  _out_of_mesh_value   ()
{
  //   std::vector<unsigned int> buf (1);
  //   buf[0] = var;
  //   _system_vars (buf);
}

MeshFunction() [3/4]

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

delete

This class is sometimes responsible for cleaning up the _point_locator, so it can't be default (shallow) copy constructed or move constructed.

MeshFunction() [4/4]

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

delete

~MeshFunction()

libMesh::MeshFunction::~MeshFunction

(

)

Destructor.

Definition at line 87 of file mesh_function.C.

{
  delete this->_point_locator;
}

References _point_locator.

Member Function Documentation

clear()

void libMesh::MeshFunction::clear ( )

overridevirtual

Clears the function.

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 121 of file mesh_function.C.

{
  // only delete the point locator when we are the master
  if ((this->_point_locator != nullptr) && (this->_master == nullptr))
    {
      delete this->_point_locator;
      this->_point_locator = nullptr;
    }
  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 134 of file mesh_function.C.

{
  MeshFunction * mf_clone =
    new MeshFunction(_eqn_systems, _vector, _dof_map, _system_vars, this);
 
  if (this->initialized())
    mf_clone->init();
  mf_clone->set_point_locator_tolerance(
    this->get_point_locator().get_close_to_point_tol());
 
  return std::unique_ptr<FunctionBase<Number>>(mf_clone);
}

References _dof_map, _eqn_systems, _system_vars, _vector, get_point_locator(), init(), libMesh::FunctionBase< Number >::initialized(), MeshFunction(), and set_point_locator_tolerance().

comm()

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

inlineinherited

Returns

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

Definition at line 94 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::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), 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::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), 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::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), 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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), 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::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), 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_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::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_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_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::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::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.

Reimplemented in TripleFunction, SolutionFunction, SolutionFunction, and SolutionFunction.

Definition at line 227 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

(

void

)

Disables out-of-mesh mode.

This is also the default.

Definition at line 814 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::PointLocatorBase::disable_out_of_mesh_mode(), 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 501 of file mesh_function.C.

{
  this->discontinuous_gradient (p, time, output, nullptr);
}

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

Build an FEComputeData that contains both input and output data for the specific compute_data method.

Definition at line 510 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)
    {
      const unsigned int dim = element->dim();
 
      // define a temporary vector to store all values
      std::vector<Gradient> 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
      std::vector<Point> point_list (1, mapped_point);
      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] = 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);
 
          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...
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
          if (!element->infinite())
            {
#endif
              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
            {
              //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
          temp_output[index] = grad;
 
          // 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::TypeVector< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::FEInterface::compute_data(), 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::DenseVector< T >::size(), and libMesh::DofMap::variable_type().

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 184 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 & pr : buffer)
    return_value[pr.first] = pr.second[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 libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by discontinuous_gradient().

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 304 of file mesh_function.C.

{
  this->discontinuous_value (p, time, output, nullptr);
}

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

Build an FEComputeData that contains both input and output data for the specific compute_data method.

Definition at line 313 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)
    {
      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);
 
          {
            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(), 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::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 159 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 & pr : buffer)
    return_value[pr.first] = pr.second(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 libMesh::FunctionBase< Number >::initialized(), and libMesh::libmesh_assert().

Referenced by discontinuous_value().

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 799 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::PointLocatorBase::enable_out_of_mesh_mode(), libMesh::FunctionBase< Number >::initialized(), libMesh::libmesh_assert(), and value.

Referenced by enable_out_of_mesh_mode().

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 807 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 700 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);
      if (_out_of_mesh_mode!=master->_out_of_mesh_mode)
        libmesh_error_msg("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 = this->_point_locator->operator()(p,subdomain_ids);
 
  // If we have an element, but it's not a local element, then we
  // either need to have a serialized vector or we need to find a
  // local element sharing the same point.
  if (element &&
      (element->processor_id() != this->processor_id()) &&
      _vector.type() != SERIAL)
    {
      // look for a local element containing the point
      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 libMesh::FunctionBase< Number >::_master, _out_of_mesh_mode, _point_locator, _vector, libMesh::Elem::find_point_neighbors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::SERIAL, and libMesh::NumericVector< T >::type().

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 744 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);
      if (_out_of_mesh_mode!=master->_out_of_mesh_mode)
        libmesh_error_msg("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;
  this->_point_locator->operator()(p,candidate_elements,subdomain_ids);
  for (const auto & element : candidate_elements)
    {
      // If we have an element, but it's not a local element, then we
      // either need to have a serialized vector or we need to find a
      // local element sharing the same point.
      if (element &&
          (element->processor_id() != this->processor_id()) &&
          _vector.type() != SERIAL)
        {
          // look for a local element containing the point
          std::set<const Elem *> point_neighbors;
          element->find_point_neighbors(p, point_neighbors);
          for (const auto & elem : point_neighbors)
            if (elem->processor_id() == this->processor_id())
              {
                final_candidate_elements.insert(elem);
                break;
              }
        }
      else
        final_candidate_elements.insert(element);
    }
 
  return final_candidate_elements;
}

References libMesh::FunctionBase< Number >::_master, _out_of_mesh_mode, _point_locator, _vector, libMesh::ParallelObject::processor_id(), libMesh::SERIAL, and libMesh::NumericVector< T >::type().

Referenced by discontinuous_gradient(), and discontinuous_value().

get_point_locator()

const PointLocatorBase & libMesh::MeshFunction::get_point_locator

(

void

)

const

Returns

The current PointLocator object, for use elsewhere.

Note

The MeshFunction object must be initialized before this is called.

Definition at line 793 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 clone().

gradient() [1/2]

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

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.

Build an FEComputeData that contains both input and output data for the specific compute_data method.

Definition at line 395 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  const Elem * element = this->find_element(p,subdomain_ids);
 
  if (!element)
    {
      output.resize(0);
      return;
    }
  else
    {
      // resize the output vector to the number of output values
      // that the user told us
      output.resize (this->_system_vars.size());
 
 
      {
        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.);
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
            //The other algorithm works in case of finite elements as well,
            //but this one is faster.
            if (!element->infinite())
              {
#endif
                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
              {
                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(), data, 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().

gradient() [2/2]

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 174 of file mesh_function.C.

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

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

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

hessian() [1/2]

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

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 620 of file mesh_function.C.

{
  libmesh_assert (this->initialized());
 
  const Elem * element = this->find_element(p,subdomain_ids);
 
  if (!element)
    {
      output.resize(0);
    }
  else
    {
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      if(element->infinite())
        libmesh_warning("Warning: Requested the Hessian of an Infinite element."
                        << "Second derivatives for Infinite elements"
                        << " are not yet implemented!"
                        << std::endl);
#endif
      // resize the output vector to the number of output values
      // that the user told us
      output.resize (this->_system_vars.size());
 
 
      {
        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, _vector, 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() [2/2]

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 200 of file mesh_function.C.

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

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

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error().

init() [1/2]

virtual void libMesh::MeshFunction::init ( )

inlineoverridevirtual

Override the FunctionBase::init() member function by calling our own and specifying the Trees::NODES method.

specifies the method to use when building a PointLocator

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 110 of file mesh_function.h.

{ this->init(Trees::NODES); }

References init(), and libMesh::Trees::NODES.

Referenced by clone(), init(), main(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), SystemsTest::testProjectCubeWithMeshFunction(), and libMesh::MeshFunctionSolutionTransfer::transfer().

init() [2/2]

void libMesh::MeshFunction::init

(

const Trees::BuildType

point_locator_build_type

)

The actual initialization process.

Takes an optional argument which specifies the method to use when building a PointLocator

Definition at line 95 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(this->_point_locator);
      return;
    }
 
  /*
   * set up the PointLocator: currently we always get this from the
   * MeshBase we're associated with.
   */
  const MeshBase & mesh = this->_eqn_systems.get_mesh();
 
  this->_point_locator = mesh.sub_point_locator().release();
 
  // 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().

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 205 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 219 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 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::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(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), 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 passed subdomain_ids.

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

Implements libMesh::FunctionBase< Number >.

Definition at line 211 of file mesh_function.C.

{
  this->operator() (p, time, output, nullptr);
}

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

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

Build an FEComputeData that contains both input and output data for the specific compute_data method.

Definition at line 218 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
    {
      // resize the output vector to the number of output values
      // that the user told us
      output.resize (cast_int<unsigned int>
                     (this->_system_vars.size()));
 
 
      {
        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));
 
        // 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);
 
            {
              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) = value;
              }
 
            }
 
            // next variable
          }
      }
    }
}

References _dof_map, _eqn_systems, _out_of_mesh_mode, _out_of_mesh_value, _system_vars, _vector, libMesh::FEInterface::compute_data(), data, dim, libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), find_element(), libMesh::index_range(), libMesh::FunctionBase< Number >::initialized(), libMesh::invalid_uint, libMesh::FEMap::inverse_map(), libMesh::libmesh_assert(), libMesh::DenseVector< T >::resize(), 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 149 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(), and libMesh::libmesh_assert().

Referenced by 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 240 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

This class contains const references so it can't be assigned.

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 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), 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_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), find_element(), find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), 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::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::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::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), 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::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), 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(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_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::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::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), 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::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_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 212 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 821 of file mesh_function.C.

{
  _point_locator->set_close_to_point_tol(tol);
}

References _point_locator, and libMesh::PointLocatorBase::set_close_to_point_tol().

Referenced by clone().

unset_point_locator_tolerance()

void libMesh::MeshFunction::unset_point_locator_tolerance

(

)

Turn off the user-specified PointLocator tolerance.

Definition at line 826 of file mesh_function.C.

{
  _point_locator->unset_close_to_point_tol();
}

References _point_locator, and libMesh::PointLocatorBase::unset_close_to_point_tol().

Member Data Documentation

_communicator

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

protectedinherited

Definition at line 112 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

_dof_map

const DofMap& libMesh::MeshFunction::_dof_map

protected

Need access to the DofMap of the other system.

Definition at line 339 of file mesh_function.h.

Referenced by clone(), discontinuous_gradient(), discontinuous_value(), gradient(), 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 328 of file mesh_function.h.

Referenced by clone(), discontinuous_gradient(), discontinuous_value(), gradient(), 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 179 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 184 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 173 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 357 of file mesh_function.h.

Referenced by disable_out_of_mesh_mode(), discontinuous_gradient(), discontinuous_value(), enable_out_of_mesh_mode(), find_element(), find_elements(), gradient(), 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 363 of file mesh_function.h.

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

_point_locator

PointLocatorBase* libMesh::MeshFunction::_point_locator

protected

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

Definition at line 351 of file mesh_function.h.

Referenced by clear(), disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), find_element(), find_elements(), get_point_locator(), init(), set_point_locator_tolerance(), unset_point_locator_tolerance(), and ~MeshFunction().

_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 345 of file mesh_function.h.

Referenced by clone(), discontinuous_gradient(), discontinuous_value(), gradient(), 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 334 of file mesh_function.h.

Referenced by clone(), discontinuous_gradient(), discontinuous_value(), find_element(), find_elements(), gradient(), hessian(), and operator()().

---

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

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