Poster of Linux kernelThe best gift for a Linux geek
MeshFunction

MeshFunction

Section: C Library Functions (3) Updated: Thu Apr 7 2011
Local index Up
 

NAME

MeshFunction -  

SYNOPSIS


#include <mesh_function.h>

Inherits FunctionBase.  

Public Member Functions


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

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

~MeshFunction ()

void init ()

void init (const Trees::BuildType point_locator_build_type)

void clear ()

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 gradient (const Point &p, const Real time, std::vector< Gradient > &output)

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

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 operator() (const Point &p, DenseVector< Number > &output)

bool initialized () 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
 

Detailed Description

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

Author:

Daniel Dreyer, 2003

Definition at line 55 of file mesh_function.h.  

Constructor & Destructor Documentation

 

MeshFunction::MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const std::vector< unsigned int > &vars, const FunctionBase *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 41 of file mesh_function.C.

                                                        :
  FunctionBase   (master),
  _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()
{
}
 

MeshFunction::MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const unsigned intvar, const FunctionBase *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 59 of file mesh_function.C.

                                                        :
  FunctionBase   (master),
  _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);
}
 

MeshFunction::~MeshFunction ()Destructor.

Definition at line 84 of file mesh_function.C.

References FunctionBase::_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;
}
 

Member Function Documentation

 

void MeshFunction::clear () [virtual]Clears the function.

Implements FunctionBase.

Definition at line 155 of file mesh_function.C.

References FunctionBase::_initialized, FunctionBase::_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;
}
 

void MeshFunction::disable_out_of_mesh_mode (void)Disables out-of-mesh mode. This is also the default.

Definition at line 512 of file mesh_function.C.

References _out_of_mesh_mode, _point_locator, PointLocatorBase::disable_out_of_mesh_mode(), and FunctionBase::initialized().

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

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

References _out_of_mesh_mode, _out_of_mesh_value, _point_locator, PointLocatorBase::enable_out_of_mesh_mode(), and FunctionBase::initialized().

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 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 505 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 PointLocatorBase & MeshFunction::get_point_locator (void) constReturns the current PointLocator object, for you might want to use it elsewhere. The MeshFunction object must be initialized before.

Definition at line 491 of file mesh_function.C.

References _point_locator, and FunctionBase::initialized().

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

void MeshFunction::gradient (const Point &p, const Realtime, std::vector< Gradient > &output)Computes gradients at coordinate p and for time time, which defaults to zero.

Definition at line 312 of file mesh_function.C.

References _dof_map, _eqn_systems, FunctionBase::_master, _out_of_mesh_mode, _point_locator, _system_vars, TypeVector< T >::add_scaled(), FEBase::build(), DofMap::dof_indices(), EquationSystems::get_mesh(), FunctionBase::initialized(), FEInterface::inverse_map(), MeshBase::mesh_dimension(), and DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  /* 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 =
        libmesh_cast_ptr<const MeshFunction*>(this->_master);
      if(_out_of_mesh_mode!=master->_out_of_mesh_mode)
        {
          std::cerr << '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.' << std::endl;
          libmesh_error();
        }
    }
#endif
  
  // locate the point in the other mesh
  const Elem* element = this->_point_locator->operator()(p);

  if(element==NULL)
    {
      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 = this->_eqn_systems.get_mesh().mesh_dimension();
        
        
        /*
         * 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);

            AutoPtr<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<unsigned int> 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;
}
 

Gradient MeshFunction::gradient (const Point &p, const Realtime = 0.)Returns:

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

Definition at line 184 of file mesh_function.C.

References FunctionBase::initialized().

Referenced by ExactErrorEstimator::find_squared_element_error().

{
  libmesh_assert (this->initialized());
  // At the moment the function we call ignores the time
  libmesh_assert (time == 0.);
  
  std::vector<Gradient> buf (1);
  this->gradient(p, time, buf);
  return buf[0];
}
 

void MeshFunction::hessian (const Point &p, const Realtime, std::vector< Tensor > &output)Computes gradients at coordinate p and for time time, which defaults to zero.

Definition at line 401 of file mesh_function.C.

References _dof_map, _eqn_systems, FunctionBase::_master, _out_of_mesh_mode, _point_locator, _system_vars, TypeTensor< T >::add_scaled(), FEBase::build(), DofMap::dof_indices(), EquationSystems::get_mesh(), FunctionBase::initialized(), FEInterface::inverse_map(), MeshBase::mesh_dimension(), and DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  /* 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 =
        libmesh_cast_ptr<const MeshFunction*>(this->_master);
      if(_out_of_mesh_mode!=master->_out_of_mesh_mode)
        {
          std::cerr << '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.' << std::endl;
          libmesh_error();
        }
    }
#endif
  
  // locate the point in the other mesh
  const Elem* element = this->_point_locator->operator()(p);

  if(element==NULL)
    {
      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 = this->_eqn_systems.get_mesh().mesh_dimension();
        
        
        /*
         * 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);

            AutoPtr<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<unsigned int> 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;
}
 

Tensor MeshFunction::hessian (const Point &p, const Realtime = 0.)Returns:

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

Definition at line 199 of file mesh_function.C.

References FunctionBase::initialized().

Referenced by ExactErrorEstimator::find_squared_element_error().

{
  libmesh_assert (this->initialized());
  // At the moment the function we call ignores the time
  libmesh_assert (time == 0.);
  
  std::vector<Tensor> buf (1);
  this->hessian(p, time, buf);
  return buf[0];
}
 

void MeshFunction::init (const Trees::BuildTypepoint_locator_build_type)The actual initialization process. Takes an optional argument which specifies the method to use when building a PointLocator

Definition at line 94 of file mesh_function.C.

References _eqn_systems, FunctionBase::_initialized, FunctionBase::_master, _point_locator, _system_vars, and EquationSystems::get_mesh().

{
  // are indices of the desired variable(s) provided?
  libmesh_assert (this->_system_vars.size() > 0);

  // Don't do twice...
  if (this->_initialized)
    {
      libmesh_assert(this->_point_locator != NULL);
      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 =
        libmesh_cast_ptr<const MeshFunction*>(this->_master);
      
      if (master->_point_locator == NULL)
        {
          std::cerr << 'ERROR: When the master-servant concept is used,'
                    << std::endl
                    << ' the master has to be initialized first!'
                    << std::endl;
          libmesh_error();
        }
      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 
TREE version available //AutoPtr<PointLocatorBase> ap (PointLocatorBase::build (TREE, mesh)); //this->_point_locator = ap.release(); this->_point_locator = new PointLocatorTree (mesh, point_locator_build_type); // Point locator no longer needs to be initialized. // this->_point_locator->init(); } // ready for use this->_initialized = true; }
 

void MeshFunction::init () [inline, virtual]The actual initialization process. specifies the method to use when building a PointLocator

Implements FunctionBase.

Definition at line 98 of file mesh_function.h.

References init(), and Trees::NODES.

Referenced by init().

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

bool FunctionBase::initialized () const [inline, inherited]Returns:

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

Definition at line 144 of file function_base.h.

References FunctionBase::_initialized.

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

{
  return (this->_initialized);
}
 

void FunctionBase::operator() (const Point &p, DenseVector< Number > &output) [inline, inherited]Return function for vectors. Returns in output the values of the data at the coordinate p.

Definition at line 152 of file function_base.h.

References FunctionBase::operator()().

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

Number MeshFunction::operator() (const Point &p, const Realtime = 0.) [virtual]Returns:

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

Implements FunctionBase.

Definition at line 170 of file mesh_function.C.

References FunctionBase::initialized().

{
  libmesh_assert (this->initialized());
  // At the moment the function we call ignores the time
  libmesh_assert (time == 0.);
  
  DenseVector<Number> buf (1);
  this->operator() (p, time, buf);
  return buf(0);
}
 

void MeshFunction::operator() (const Point &p, const Realtime, DenseVector< Number > &output) [virtual]Computes values at coordinate p and for time time, which defaults to zero.

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

Implements FunctionBase.

Definition at line 214 of file mesh_function.C.

References _dof_map, _eqn_systems, FunctionBase::_master, _out_of_mesh_mode, _out_of_mesh_value, _point_locator, _system_vars, _vector, FEInterface::compute_data(), DofMap::dof_indices(), EquationSystems::get_mesh(), FunctionBase::initialized(), FEInterface::inverse_map(), MeshBase::mesh_dimension(), DenseVector< T >::resize(), FEComputeData::shape, and DofMap::variable_type().

{
  libmesh_assert (this->initialized());

  /* 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 =
        libmesh_cast_ptr<const MeshFunction*>(this->_master);
      if(_out_of_mesh_mode!=master->_out_of_mesh_mode)
        {
          std::cerr << '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.' << std::endl;
          libmesh_error();
        }
    }
#endif
  
  // locate the point in the other mesh
  const Elem* element = this->_point_locator->operator()(p);

  if(element==NULL)
    {
      output = _out_of_mesh_value;      
    }
  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 = this->_eqn_systems.get_mesh().mesh_dimension();
        
        
        /*
         * 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<unsigned int> 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;
}
 

Member Data Documentation

 

const DofMap& MeshFunction::_dof_map [protected]Need access to the DofMap of the other system.

Definition at line 213 of file mesh_function.h.

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

const EquationSystems& MeshFunction::_eqn_systems [protected]The equation systems handler, from which the data are gathered.

Definition at line 202 of file mesh_function.h.

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

bool FunctionBase::_initialized [protected, inherited]When init() was called so that everything is ready for calls to operator() (...), then this bool is true.

Definition at line 136 of file function_base.h.

Referenced by AnalyticFunction::AnalyticFunction(), clear(), init(), AnalyticFunction::init(), and FunctionBase::initialized().  

const FunctionBase* FunctionBase::_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 130 of file function_base.h.

Referenced by clear(), gradient(), hessian(), init(), operator()(), and ~MeshFunction().  

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

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

DenseVector<Number> 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 237 of file mesh_function.h.

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

PointLocatorBase* MeshFunction::_point_locator [protected]A point locator is needed to locate the points in the mesh.

Definition at line 225 of file mesh_function.h.

Referenced by clear(), disable_out_of_mesh_mode(), enable_out_of_mesh_mode(), get_point_locator(), gradient(), hessian(), init(), operator()(), and ~MeshFunction().  

const std::vector<unsigned int> MeshFunction::_system_vars [protected]The indices of the variables within the other system for which data are to be gathered.

Definition at line 219 of file mesh_function.h.

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

const NumericVector<Number>& MeshFunction::_vector [protected]A reference to the vector that holds the data that is to be interpolated.

Definition at line 208 of file mesh_function.h.

Referenced by operator()().

 

Author

Generated automatically by Doxygen for libMesh from the source code.


 

Index

NAME
SYNOPSIS
Public Member Functions
Protected Attributes
Detailed Description
Constructor & Destructor Documentation
MeshFunction::MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const std::vector< unsigned int > &vars, const FunctionBase *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.
MeshFunction::MeshFunction (const EquationSystems &eqn_systems, const NumericVector< Number > &vec, const DofMap &dof_map, const unsigned intvar, const FunctionBase *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.
MeshFunction::~MeshFunction ()Destructor.
Member Function Documentation
void MeshFunction::clear () [virtual]Clears the function.
void MeshFunction::disable_out_of_mesh_mode (void)Disables out-of-mesh mode. This is also the default.
void 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.
void 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.
const PointLocatorBase & MeshFunction::get_point_locator (void) constReturns the current PointLocator object, for you might want to use it elsewhere. The MeshFunction object must be initialized before.
void MeshFunction::gradient (const Point &p, const Realtime, std::vector< Gradient > &output)Computes gradients at coordinate p and for time time, which defaults to zero.
Gradient MeshFunction::gradient (const Point &p, const Realtime = 0.)Returns:
void MeshFunction::hessian (const Point &p, const Realtime, std::vector< Tensor > &output)Computes gradients at coordinate p and for time time, which defaults to zero.
Tensor MeshFunction::hessian (const Point &p, const Realtime = 0.)Returns:
void MeshFunction::init (const Trees::BuildTypepoint_locator_build_type)The actual initialization process. Takes an optional argument which specifies the method to use when building a PointLocator
void MeshFunction::init () [inline, virtual]The actual initialization process. specifies the method to use when building a PointLocator
bool FunctionBase::initialized () const [inline, inherited]Returns:
void FunctionBase::operator() (const Point &p, DenseVector< Number > &output) [inline, inherited]Return function for vectors. Returns in output the values of the data at the coordinate p.
Number MeshFunction::operator() (const Point &p, const Realtime = 0.) [virtual]Returns:
void MeshFunction::operator() (const Point &p, const Realtime, DenseVector< Number > &output) [virtual]Computes values at coordinate p and for time time, which defaults to zero.
Member Data Documentation
const DofMap& MeshFunction::_dof_map [protected]Need access to the DofMap of the other system.
const EquationSystems& MeshFunction::_eqn_systems [protected]The equation systems handler, from which the data are gathered.
bool FunctionBase::_initialized [protected, inherited]When init() was called so that everything is ready for calls to operator() (...), then this bool is true.
const FunctionBase* FunctionBase::_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.
bool 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.
DenseVector<Number> 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.
PointLocatorBase* MeshFunction::_point_locator [protected]A point locator is needed to locate the points in the mesh.
const std::vector<unsigned int> MeshFunction::_system_vars [protected]The indices of the variables within the other system for which data are to be gathered.
const NumericVector<Number>& MeshFunction::_vector [protected]A reference to the vector that holds the data that is to be interpolated.
Author

This document was created by man2html, using the manual pages.
Time: 21:50:10 GMT, April 16, 2011