#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=NULL)
	MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const unsigned int var, const FunctionBase< Number > *master=NULL)
	~MeshFunction ()
void	init ()
virtual void	init (const Trees::BuildType point_locator_build_type)
virtual void	clear ()
virtual UniquePtr < FunctionBase< Number > >	clone () const
Number	operator() (const Point &p, const Real time=0.)
Gradient	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)
void	operator() (const Point &p, const Real time, DenseVector< Number > &output, const std::set< subdomain_id_type > *subdomain_ids)
void	gradient (const Point &p, const Real time, std::vector< Gradient > &output, const std::set< subdomain_id_type > *subdomain_ids=NULL)
void	hessian (const Point &p, const Real time, std::vector< Tensor > &output, const std::set< subdomain_id_type > *subdomain_ids=NULL)
const PointLocatorBase &	get_point_locator (void) const
void	enable_out_of_mesh_mode (const DenseVector< Number > &value)
void	enable_out_of_mesh_mode (const Number &value)
void	disable_out_of_mesh_mode (void)
void	set_point_locator_tolerance (Real tol)
void	unset_point_locator_tolerance ()
void	operator() (const Point &p, DenseVector< Number > &output)
virtual Number	component (unsigned int i, const Point &p, Real time=0.)
bool	initialized () 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=NULL) const
Protected Attributes
const EquationSystems &	_eqn_systems
const NumericVector< Number > &	_vector
const DofMap &	_dof_map
const std::vector< unsigned int >	_system_vars
PointLocatorBase *	_point_locator
bool	_out_of_mesh_mode
DenseVector< Number >	_out_of_mesh_value
const FunctionBase *	_master
bool	_initialized
const Parallel::Communicator &	_communicator

Detailed Description

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

Author:: Daniel Dreyer, 2003

Definition at line 57 of file mesh_function.h.

Constructor & Destructor Documentation

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 = `NULL`
	)

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.

Referenced by clone().

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

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

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

libMesh::MeshFunction::~MeshFunction ( )

Destructor.

Definition at line 87 of file mesh_function.C.

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

{
  // only delete the point locator when we are the master
  if (this->_master == NULL)
    delete this->_point_locator;
}

Member Function Documentation

void libMesh::MeshFunction::clear ( ) [virtual]

Clears the function.

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 153 of file mesh_function.C.

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

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

UniquePtr< FunctionBase< Number > > libMesh::MeshFunction::clone ( ) const [virtual]

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 that this implies the copy should not be used after the original is destroyed.

Implements libMesh::FunctionBase< Number >.

Definition at line 166 of file mesh_function.C.

References _dof_map, _eqn_systems, _system_vars, _vector, and MeshFunction().

{
  return UniquePtr<FunctionBase<Number> >
    (new MeshFunction
     (_eqn_systems, _vector, _dof_map, _system_vars, this));
}

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const [inline, inherited]

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

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

  { return _communicator; }

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

Returns:: the vector component i at coordinate p and time time. Subclasses aren't required to overload this, since the default implementation is based on the full vector evaluation, which is often correct. Subclasses are recommended to overload this, since the default implementation is based on a vector evaluation, which is usually unnecessarily inefficient.

void libMesh::MeshFunction::disable_out_of_mesh_mode ( void )

Disables out-of-mesh mode. This is also the default.

Definition at line 510 of file mesh_function.C.

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

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

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

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

Referenced by enable_out_of_mesh_mode().

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

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

References enable_out_of_mesh_mode().

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

const Elem * libMesh::MeshFunction::find_element	(	const Point &	p,
		const std::set< subdomain_id_type > *	subdomain_ids = `NULL`
	)		const `[protected]`

Helper function to reduce code duplication

Definition at line 440 of file mesh_function.C.

References libMesh::FunctionBase< Number >::_master, _out_of_mesh_mode, _point_locator, _vector, end, 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()().

{
  /* 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 != NULL)
    {
      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 = NULL;
      std::set<const Elem*>::const_iterator       it  = point_neighbors.begin();
      const std::set<const Elem*>::const_iterator end = point_neighbors.end();
      for (; it != end; ++it)
        {
          const Elem* elem = *it;
          if (elem->processor_id() == this->processor_id())
            {
              element = elem;
              break;
            }
        }
    }

  return element;
}

const PointLocatorBase & libMesh::MeshFunction::get_point_locator ( void ) const

Returns the current PointLocator object, for you might want to use it elsewhere. The MeshFunction object must be initialized before.

Definition at line 489 of file mesh_function.C.

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

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

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

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

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

{
  libmesh_assert (this->initialized());

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

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

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

References _dof_map, _system_vars, libMesh::TypeVector< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), find_element(), libMesh::FunctionBase< Number >::initialized(), libMesh::FEInterface::inverse_map(), libMesh::libmesh_assert(), and libMesh::DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  const Elem* element = this->find_element(p,subdomain_ids);

  if (!element)
    {
      output.resize(0);
    }
  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 (FEInterface::inverse_map (dim,
                                                            this->_dof_map.variable_type(0),
                                                            element,
                                                            p));

        std::vector<Point> point_list (1, mapped_point);

        // loop over all vars
        for (unsigned int index=0; index < this->_system_vars.size(); index++)
          {
            /*
             * the data for this variable
             */
            const unsigned int var = _system_vars[index];
            const FEType& fe_type = this->_dof_map.variable_type(var);

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

            // 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 (unsigned int i=0; i<dof_indices.size(); i++)
              grad.add_scaled(dphi[i][0], this->_vector(dof_indices[i]));

            output[index] = grad;
          }
      }
    }

  // all done
  return;
}

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.

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

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

{
  libmesh_assert (this->initialized());

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

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

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

References _dof_map, _system_vars, libMesh::TypeTensor< T >::add_scaled(), libMesh::FEGenericBase< OutputType >::build(), libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), find_element(), libMesh::FunctionBase< Number >::initialized(), libMesh::FEInterface::inverse_map(), libMesh::libmesh_assert(), and libMesh::DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  const Elem* element = this->find_element(p,subdomain_ids);

  if (!element)
    {
      output.resize(0);
    }
  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 (FEInterface::inverse_map (dim,
                                                            this->_dof_map.variable_type(0),
                                                            element,
                                                            p));

        std::vector<Point> point_list (1, mapped_point);

        // loop over all vars
        for (unsigned int index=0; index < this->_system_vars.size(); index++)
          {
            /*
             * the data for this variable
             */
            const unsigned int var = _system_vars[index];
            const FEType& fe_type = this->_dof_map.variable_type(var);

            UniquePtr<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 (unsigned int i=0; i<dof_indices.size(); i++)
              hess.add_scaled(d2phi[i][0], this->_vector(dof_indices[i]));

            output[index] = hess;
          }
      }
    }

  // all done
  return;
}

void libMesh::MeshFunction::init ( ) [inline, virtual]

The actual initialization process. specifies the method to use when building a PointLocator

Reimplemented from libMesh::FunctionBase< Number >.

Definition at line 101 of file mesh_function.h.

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

Referenced by init().

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

void libMesh::MeshFunction::init ( const Trees::BuildType point_locator_build_type ) [virtual]

The actual initialization process. Takes an optional argument which specifies the method to use when building a PointLocator

Definition at line 97 of file mesh_function.C.

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

{
  // 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: either someone else
   * is the master (go and get the address of his
   * point locator) or this object is the master
   * (build the point locator  on our own).
   */
  if (this->_master != NULL)
    {
      // we aren't the master
      const MeshFunction* master =
        cast_ptr<const MeshFunction*>(this->_master);

      if (master->_point_locator == NULL)
        libmesh_error_msg("ERROR: When the master-servant concept is used, the master has to be initialized first!");

      else
        {
          this->_point_locator = master->_point_locator;
        }
    }
  else
    {
      // we are the master: build the point locator

      // constant reference to the other mesh
      const MeshBase& mesh = this->_eqn_systems.get_mesh();

      // build the point locator.  Only \p TREE version available
      //UniquePtr<PointLocatorBase> ap (PointLocatorBase::build (TREE, mesh));
      //this->_point_locator = ap.release();
      // this->_point_locator = new PointLocatorTree (mesh, point_locator_build_type);
      this->_point_locator = mesh.sub_point_locator().release();

      // Point locator no longer needs to be initialized.
      //      this->_point_locator->init();
    }


  // ready for use
  this->_initialized = true;
}

bool libMesh::FunctionBase< Number >::initialized ( ) const [inherited]

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

Referenced by disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), get_point_locator(), gradient(), hessian(), and operator()().

processor_id_type libMesh::ParallelObject::n_processors ( ) const [inline, inherited]

Returns:: the number of processors in the group.

Definition at line 92 of file parallel_object.h.

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

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

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

Return function for vectors. Returns in output the values of the data at the coordinate p.

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

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

Implements libMesh::FunctionBase< Number >.

Definition at line 175 of file mesh_function.C.

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

Referenced by operator()().

{
  libmesh_assert (this->initialized());

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

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

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.

References operator()().

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

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.

References _dof_map, _eqn_systems, _out_of_mesh_value, _system_vars, _vector, libMesh::FEInterface::compute_data(), data, libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), find_element(), libMesh::FunctionBase< Number >::initialized(), libMesh::FEInterface::inverse_map(), libMesh::libmesh_assert(), libMesh::DenseVector< T >::resize(), libMesh::FEComputeData::shape, and libMesh::DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  const Elem* element = this->find_element(p,subdomain_ids);

  if (!element)
    {
      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 (FEInterface::inverse_map (dim,
                                                            this->_dof_map.variable_type(0),
                                                            element,
                                                            p));


        // loop over all vars
        for (unsigned int index=0; index < this->_system_vars.size(); index++)
          {
            /*
             * the data for this variable
             */
            const unsigned int var = _system_vars[index];
            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 (unsigned int i=0; i<dof_indices.size(); i++)
                  value += this->_vector(dof_indices[i]) * data.shape[i];

                output(index) = value;
              }

            }

            // next variable
          }
      }
    }

  // all done
  return;
}

processor_id_type libMesh::ParallelObject::processor_id ( ) const [inline, inherited]

Returns:: the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

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

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

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

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

{
  // We need to enable out_of_mesh mode in the point_locator
  // in order for the point locator tolerance to be used.
  _point_locator->enable_out_of_mesh_mode();

  // Set the tolerance
  _point_locator->set_close_to_point_tol(tol);
}

void libMesh::MeshFunction::unset_point_locator_tolerance ( )

Turn off the user-specified PointLocator tolerance.

Definition at line 527 of file mesh_function.C.

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

{
  _point_locator->unset_close_to_point_tol();
}

Member Data Documentation

const Parallel::Communicator& libMesh::ParallelObject::_communicator [protected, inherited]

Definition at line 104 of file parallel_object.h.

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

const DofMap& libMesh::MeshFunction::_dof_map [protected]

Need access to the DofMap of the other system.

Definition at line 261 of file mesh_function.h.

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

const EquationSystems& libMesh::MeshFunction::_eqn_systems [protected]

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

Definition at line 250 of file mesh_function.h.

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

bool libMesh::FunctionBase< Number >::_initialized [protected, inherited]

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

Definition at line 170 of file function_base.h.

Referenced by clear(), and init().

const FunctionBase* libMesh::FunctionBase< Number >::_master [protected, inherited]

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

Definition at line 164 of file function_base.h.

Referenced by clear(), find_element(), init(), and ~MeshFunction().

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

Referenced by disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), and find_element().

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

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

PointLocatorBase* libMesh::MeshFunction::_point_locator [protected]

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