const Quadrature<dim> &quadrature,
const Function<spacedim,typename VectorType::value_type> &function,
VectorType &vec,
- const bool enforce_zero_boundary = false,
+ const bool enforce_zero_boundary = false,
const Quadrature<dim-1> &q_boundary = (dim > 1 ?
QGauss<dim-1>(2) :
Quadrature<dim-1>(0)),
- const bool project_to_boundary_first = false);
+ const bool project_to_boundary_first = false);
/**
* Same as above, but for arguments of type hp::DoFHandler,
const hp::QCollection<dim> &quadrature,
const Function<spacedim,typename VectorType::value_type> &function,
VectorType &vec,
- const bool enforce_zero_boundary = false,
+ const bool enforce_zero_boundary = false,
const hp::QCollection<dim-1> &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
QGauss<dim-1>(2) :
Quadrature<dim-1>(0)),
- const bool project_to_boundary_first = false);
+ const bool project_to_boundary_first = false);
/**
* Call the project() function above, with a collection of $Q_1$ mapping
void project (const hp::DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const hp::QCollection<dim> &quadrature,
- const Function<spacedim,typename VectorType::value_type> &function,
+ const Function<spacedim,typename VectorType::value_type> &function,
VectorType &vec,
- const bool enforce_zero_boundary = false,
+ const bool enforce_zero_boundary = false,
const hp::QCollection<dim-1> &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
QGauss<dim-1>(2) :
Quadrature<dim-1>(0)),
- const bool project_to_boundary_first = false);
+ const bool project_to_boundary_first = false);
/**
* Compute Dirichlet boundary conditions. This function makes up a map of
template <int dim, int spacedim, typename number>
void
interpolate_boundary_values
- (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
+ (const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
const std::map<types::boundary_id, const Function<spacedim,number>*> &function_map,
- std::map<types::global_dof_index,number> &boundary_values,
- const ComponentMask &component_mask = ComponentMask());
+ std::map<types::global_dof_index,number> &boundary_values,
+ const ComponentMask &component_mask = ComponentMask());
/**
* Same function as above, but taking only one pair of boundary indicator
* component in @p dof. By default, no remapping is applied.
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* Call the project_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
- const Quadrature<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
+ const Quadrature<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* Same as above, but for objects of type hp::DoFHandler
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const hp::QCollection<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const hp::QCollection<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* Call the project_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const hp::DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
- const hp::QCollection<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const hp::DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
+ const hp::QCollection<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* Project a function to the boundary of the domain, using the given
* @ingroup constraints
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- ConstraintMatrix &constraints,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ ConstraintMatrix &constraints,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* Call the project_boundary_values() function, see above, with
* @ingroup constraints
*/
template <int dim, int spacedim, typename number>
- void project_boundary_values (const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
- const Quadrature<dim-1> &q,
- ConstraintMatrix &constraints,
- std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
+ void project_boundary_values
+ (const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
+ const Quadrature<dim-1> &q,
+ ConstraintMatrix &constraints,
+ std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim>
- void project_boundary_values_curl_conforming (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
+ void project_boundary_values_curl_conforming
+ (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
/**
* Same as above for the hp-namespace.
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim>
- void project_boundary_values_curl_conforming (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
+ void project_boundary_values_curl_conforming
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
/**
* This function is an updated version of the
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim>
- void project_boundary_values_curl_conforming_l2 (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
+ void project_boundary_values_curl_conforming_l2
+ (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
/**
* @ingroup constraints
*/
template <int dim>
- void project_boundary_values_curl_conforming_l2 (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
+ void project_boundary_values_curl_conforming_l2
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
/**
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template<int dim>
- void project_boundary_values_div_conforming (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
+ void project_boundary_values_div_conforming
+ (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
/**
* Same as above for the hp-namespace.
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template<int dim>
- void project_boundary_values_div_conforming (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim,double> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
+ void project_boundary_values_div_conforming
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim,double> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim, dim> &mapping_collection
+ = hp::StaticMappingQ1<dim>::mapping_collection);
/**
*/
template <int dim, int spacedim>
void create_right_hand_side (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const Quadrature<dim> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector);
+ const DoFHandler<dim,spacedim> &dof,
+ const Quadrature<dim> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector);
/**
* Call the create_right_hand_side() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
- void create_right_hand_side (const DoFHandler<dim,spacedim> &dof,
- const Quadrature<dim> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector);
+ void create_right_hand_side (const DoFHandler<dim,spacedim> &dof,
+ const Quadrature<dim> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector);
/**
* Like the previous set of functions, but for hp objects.
*/
template <int dim, int spacedim>
- void create_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
- const hp::QCollection<dim> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector);
+ void create_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
+ const hp::QCollection<dim> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector);
/**
* Like the previous set of functions, but for hp objects.
*/
template <int dim, int spacedim>
void create_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof,
- const hp::QCollection<dim> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector);
+ const hp::QCollection<dim> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector);
/**
* Create a right hand side vector for a point source at point @p p. In
template <int dim, int spacedim>
void create_point_source_vector(const Mapping<dim,spacedim> &mapping,
const DoFHandler<dim,spacedim> &dof,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector);
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector);
/**
* Call the create_point_source_vector() function, see above, with
*/
template <int dim, int spacedim>
void create_point_source_vector(const DoFHandler<dim,spacedim> &dof,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector);
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector);
/**
* Like the previous set of functions, but for hp objects.
*/
template <int dim, int spacedim>
- void create_point_source_vector(const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector);
+ void create_point_source_vector(const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector);
/**
* Like the previous set of functions, but for hp objects. The function uses
*/
template <int dim, int spacedim>
void create_point_source_vector(const hp::DoFHandler<dim,spacedim> &dof,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector);
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector);
/**
* Create a right hand side vector for a point source at point @p p. This
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
- void create_boundary_right_hand_side (const DoFHandler<dim,spacedim> &dof,
- const Quadrature<dim-1> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
+ void create_boundary_right_hand_side
+ (const DoFHandler<dim,spacedim> &dof,
+ const Quadrature<dim-1> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Same as the set of functions above, but for hp objects.
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
- void create_boundary_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
- const hp::QCollection<dim-1> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
+ void create_boundary_right_hand_side
+ (const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
+ const hp::QCollection<dim-1> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
* Call the create_boundary_right_hand_side() function, see above, with a
* @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
*/
template <int dim, int spacedim>
- void create_boundary_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof,
- const hp::QCollection<dim-1> &q,
- const Function<spacedim,double> &rhs,
- Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
+ void create_boundary_right_hand_side
+ (const hp::DoFHandler<dim,spacedim> &dof,
+ const hp::QCollection<dim-1> &q,
+ const Function<spacedim,double> &rhs,
+ Vector<double> &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
//@}
/**
* Vector<float>.
*/
template <int dim, class InVector, class OutVector, int spacedim>
- void integrate_difference (const Mapping<dim,spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim,double> &exact_solution,
- OutVector &difference,
- const Quadrature<dim> &q,
- const NormType &norm,
- const Function<spacedim,double> *weight = 0,
- const double exponent = 2.);
+ void integrate_difference (const Mapping<dim,spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const InVector &fe_function,
+ const Function<spacedim,double> &exact_solution,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim,double> *weight = 0,
+ const double exponent = 2.);
/**
* Call the integrate_difference() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, class InVector, class OutVector, int spacedim>
- void integrate_difference (const DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim,double> &exact_solution,
- OutVector &difference,
- const Quadrature<dim> &q,
- const NormType &norm,
- const Function<spacedim,double> *weight = 0,
- const double exponent = 2.);
+ void integrate_difference (const DoFHandler<dim,spacedim> &dof,
+ const InVector &fe_function,
+ const Function<spacedim,double> &exact_solution,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim,double> *weight = 0,
+ const double exponent = 2.);
/**
* Same as above for hp.
void integrate_difference (const hp::MappingCollection<dim,spacedim> &mapping,
const hp::DoFHandler<dim,spacedim> &dof,
const InVector &fe_function,
- const Function<spacedim,double> &exact_solution,
+ const Function<spacedim,double> &exact_solution,
OutVector &difference,
const hp::QCollection<dim> &q,
const NormType &norm,
- const Function<spacedim,double> *weight = 0,
- const double exponent = 2.);
+ const Function<spacedim,double> *weight = 0,
+ const double exponent = 2.);
/**
* Call the integrate_difference() function, see above, with
template <int dim, class InVector, class OutVector, int spacedim>
void integrate_difference (const hp::DoFHandler<dim,spacedim> &dof,
const InVector &fe_function,
- const Function<spacedim,double> &exact_solution,
+ const Function<spacedim,double> &exact_solution,
OutVector &difference,
const hp::QCollection<dim> &q,
const NormType &norm,
- const Function<spacedim,double> *weight = 0,
- const double exponent = 2.);
+ const Function<spacedim,double> *weight = 0,
+ const double exponent = 2.);
/**
* Take a Vector @p cellwise_error of errors on each cell with
*/
template <int dim, int spacedim, class InVector>
double compute_global_error(const Triangulation<dim,spacedim> &tria,
- const InVector &cellwise_error,
- const NormType &norm,
- const double exponent = 2.);
+ const InVector &cellwise_error,
+ const NormType &norm,
+ const double exponent = 2.);
/**
* Point error evaluation. Find the first cell containing the given point
* exception of type VectorTools::ExcPointNotAvailableHere is thrown.
*/
template <int dim, typename VectorType, int spacedim>
- void point_difference (const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Function<spacedim,typename VectorType::value_type> &exact_solution,
- Vector<typename VectorType::value_type> &difference,
- const Point<spacedim> &point);
+ void point_difference
+ (const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Function<spacedim,typename VectorType::value_type> &exact_solution,
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point);
/**
* Point error evaluation. Find the first cell containing the given point
* exception of type VectorTools::ExcPointNotAvailableHere is thrown.
*/
template <int dim, typename VectorType, int spacedim>
- void point_difference (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Function<spacedim,typename VectorType::value_type> &exact_solution,
- Vector<typename VectorType::value_type> &difference,
- const Point<spacedim> &point);
+ void point_difference
+ (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Function<spacedim,typename VectorType::value_type> &exact_solution,
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point);
/**
* Evaluate a possibly vector-valued finite element function defined by the
*/
template <int dim, typename VectorType, int spacedim>
void
- point_value (const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value);
+ point_value (const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value);
/**
* Same as above for hp.
*/
template <int dim, typename VectorType, int spacedim>
void
- point_value (const hp::DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value);
+ point_value (const hp::DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value);
/**
* Evaluate a scalar finite element function defined by the given DoFHandler
*/
template <int dim, typename VectorType, int spacedim>
void
- point_value (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value);
+ point_value (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value);
/**
* Same as above for hp.
const hp::DoFHandler<dim,spacedim> &dof,
const VectorType &fe_function,
const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value);
+ Vector<typename VectorType::value_type> &value);
/**
* Evaluate a scalar finite element function defined by the given DoFHandler
*/
template <int dim, typename VectorType, int spacedim>
void
- point_gradient (const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
+ point_gradient (const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type> > &value);
/**
*/
template <int dim, typename VectorType, int spacedim>
void
- point_gradient (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
+ point_gradient (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
std::vector<Tensor<1, spacedim, typename VectorType::value_type> > &value);
/**
template <typename VectorType, int dim, int spacedim,
template <int, int> class DoFHandlerType>
- void interpolate (const Mapping<dim,spacedim> &mapping,
- const DoFHandlerType<dim,spacedim> &dof,
- const Function<spacedim, typename VectorType::value_type> &function,
- VectorType &vec,
- const ComponentMask &component_mask)
+ void interpolate (const Mapping<dim,spacedim> &mapping,
+ const DoFHandlerType<dim,spacedim> &dof,
+ const Function<spacedim, typename VectorType::value_type> &function,
+ VectorType &vec,
+ const ComponentMask &component_mask)
{
typedef typename VectorType::value_type number;
Assert (component_mask.represents_n_components(dof.get_fe().n_components()),
template <int dim, class InVector, class OutVector, int spacedim>
void
- interpolate (const DoFHandler<dim,spacedim> &dof_1,
- const DoFHandler<dim,spacedim> &dof_2,
- const FullMatrix<double> &transfer,
- const InVector &data_1,
- OutVector &data_2)
+ interpolate (const DoFHandler<dim,spacedim> &dof_1,
+ const DoFHandler<dim,spacedim> &dof_2,
+ const FullMatrix<double> &transfer,
+ const InVector &data_1,
+ OutVector &data_2)
{
typedef typename OutVector::value_type number;
Vector<number> cell_data_1(dof_1.get_fe().dofs_per_cell);
void
interpolate_to_different_mesh
(const InterGridMap<DoFHandlerType<dim, spacedim> > &intergridmap,
- const VectorType &u1,
- const ConstraintMatrix &constraints,
- VectorType &u2)
+ const VectorType &u1,
+ const ConstraintMatrix &constraints,
+ VectorType &u2)
{
const DoFHandlerType<dim, spacedim> &dof1 = intergridmap.get_source_grid();
const DoFHandlerType<dim, spacedim> &dof2 = intergridmap.get_destination_grid();
* that is already constrained to something else
*/
template <typename number>
- bool constraints_and_b_v_are_compatible (const ConstraintMatrix &constraints,
- std::map<types::global_dof_index,number> &boundary_values)
+ bool constraints_and_b_v_are_compatible
+ (const ConstraintMatrix &constraints,
+ std::map<types::global_dof_index,number> &boundary_values)
{
for (typename std::map<types::global_dof_index,number>::iterator it=boundary_values.begin();
it != boundary_values.end(); ++it)
template <typename number>
void invert_mass_matrix(const SparseMatrix<number> &mass_matrix,
- const Vector<number> &rhs,
- Vector<number> &solution)
+ const Vector<number> &rhs,
+ Vector<number> &solution)
{
// Allow for a maximum of 5*n steps to reduce the residual by 10^-12. n
// steps may not be sufficient, since roundoff errors may accumulate for
const DoFHandlerType<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Q_or_QC<dim> &quadrature,
- const Function<spacedim, typename VectorType::value_type> &function,
+ const Function<spacedim, typename VectorType::value_type> &function,
VectorType &vec_result,
const bool enforce_zero_boundary,
const Q_or_QC<dim-1> &q_boundary,
const DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Quadrature<dim> &quadrature,
- const Function<spacedim, typename VectorType::value_type> &function,
+ const Function<spacedim, typename VectorType::value_type> &function,
VectorType &vec_result,
const bool enforce_zero_boundary,
const Quadrature<dim-1> &q_boundary,
void project (const DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const Quadrature<dim> &quadrature,
- const Function<spacedim, typename VectorType::value_type> &function,
+ const Function<spacedim, typename VectorType::value_type> &function,
VectorType &vec,
- const bool enforce_zero_boundary,
+ const bool enforce_zero_boundary,
const Quadrature<dim-1> &q_boundary,
- const bool project_to_boundary_first)
+ const bool project_to_boundary_first)
{
project(StaticMappingQ1<dim,spacedim>::mapping, dof, constraints, quadrature, function, vec,
enforce_zero_boundary, q_boundary, project_to_boundary_first);
const hp::DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const hp::QCollection<dim> &quadrature,
- const Function<spacedim, typename VectorType::value_type> &function,
+ const Function<spacedim, typename VectorType::value_type> &function,
VectorType &vec_result,
- const bool enforce_zero_boundary,
+ const bool enforce_zero_boundary,
const hp::QCollection<dim-1> &q_boundary,
- const bool project_to_boundary_first)
+ const bool project_to_boundary_first)
{
do_project (mapping, dof, constraints, quadrature,
function, vec_result,
void project (const hp::DoFHandler<dim,spacedim> &dof,
const ConstraintMatrix &constraints,
const hp::QCollection<dim> &quadrature,
- const Function<spacedim, typename VectorType::value_type> &function,
+ const Function<spacedim, typename VectorType::value_type> &function,
VectorType &vec,
- const bool enforce_zero_boundary,
+ const bool enforce_zero_boundary,
const hp::QCollection<dim-1> &q_boundary,
- const bool project_to_boundary_first)
+ const bool project_to_boundary_first)
{
project(hp::StaticMappingQ1<dim,spacedim>::mapping_collection,
dof, constraints, quadrature, function, vec,
template <int dim, int spacedim>
- void create_right_hand_side (const Mapping<dim, spacedim> &mapping,
+ void create_right_hand_side (const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim,spacedim> &dof_handler,
- const Quadrature<dim> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector)
+ const Quadrature<dim> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector)
{
const FiniteElement<dim,spacedim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
template <int dim, int spacedim>
- void create_right_hand_side (const DoFHandler<dim,spacedim> &dof_handler,
- const Quadrature<dim> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector)
+ void create_right_hand_side (const DoFHandler<dim,spacedim> &dof_handler,
+ const Quadrature<dim> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector)
{
create_right_hand_side(StaticMappingQ1<dim,spacedim>::mapping, dof_handler, quadrature,
rhs_function, rhs_vector);
template <int dim, int spacedim>
- void create_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof_handler,
- const hp::QCollection<dim> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector)
+ void create_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const hp::QCollection<dim> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector)
{
const hp::FECollection<dim,spacedim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
template <int dim, int spacedim>
- void create_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof_handler,
- const hp::QCollection<dim> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector)
+ void create_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const hp::QCollection<dim> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector)
{
create_right_hand_side(hp::StaticMappingQ1<dim,spacedim>::mapping_collection,
dof_handler, quadrature,
template <int dim, int spacedim>
- void create_point_source_vector (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
Assert (rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
- void create_point_source_vector (const DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
create_point_source_vector(StaticMappingQ1<dim,spacedim>::mapping, dof_handler,
p, rhs_vector);
template <int dim, int spacedim>
- void create_point_source_vector (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const hp::MappingCollection<dim,spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
Assert (rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
- void create_point_source_vector (const hp::DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ Vector<double> &rhs_vector)
{
create_point_source_vector(hp::StaticMappingQ1<dim>::mapping_collection,
dof_handler,
template <int dim, int spacedim>
- void create_point_source_vector (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- const Point<dim> &orientation,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
Assert (rhs_vector.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(rhs_vector.size(), dof_handler.n_dofs()));
template <int dim, int spacedim>
- void create_point_source_vector (const DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- const Point<dim> &orientation,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
create_point_source_vector(StaticMappingQ1<dim,spacedim>::mapping, dof_handler,
p, orientation, rhs_vector);
template <int dim, int spacedim>
- void create_point_source_vector (const hp::DoFHandler<dim,spacedim> &dof_handler,
- const Point<spacedim> &p,
- const Point<dim> &orientation,
- Vector<double> &rhs_vector)
+ void create_point_source_vector (const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const Point<spacedim> &p,
+ const Point<dim> &orientation,
+ Vector<double> &rhs_vector)
{
create_point_source_vector(hp::StaticMappingQ1<dim>::mapping_collection,
dof_handler,
template <int dim, int spacedim>
void
- create_boundary_right_hand_side (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof_handler,
- const Quadrature<dim-1> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector,
+ create_boundary_right_hand_side (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof_handler,
+ const Quadrature<dim-1> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector,
const std::set<types::boundary_id> &boundary_ids)
{
const FiniteElement<dim> &fe = dof_handler.get_fe();
template <int dim, int spacedim>
void
- create_boundary_right_hand_side (const DoFHandler<dim,spacedim> &dof_handler,
- const Quadrature<dim-1> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector,
+ create_boundary_right_hand_side (const DoFHandler<dim,spacedim> &dof_handler,
+ const Quadrature<dim-1> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector,
const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(StaticMappingQ1<dim>::mapping, dof_handler,
template <int dim, int spacedim>
void
create_boundary_right_hand_side (const hp::MappingCollection<dim,spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof_handler,
- const hp::QCollection<dim-1> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector,
- const std::set<types::boundary_id> &boundary_ids)
+ const hp::DoFHandler<dim,spacedim> &dof_handler,
+ const hp::QCollection<dim-1> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector,
+ const std::set<types::boundary_id> &boundary_ids)
{
const hp::FECollection<dim> &fe = dof_handler.get_fe();
Assert (fe.n_components() == rhs_function.n_components,
template <int dim, int spacedim>
void
create_boundary_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof_handler,
- const hp::QCollection<dim-1> &quadrature,
- const Function<spacedim> &rhs_function,
- Vector<double> &rhs_vector,
+ const hp::QCollection<dim-1> &quadrature,
+ const Function<spacedim> &rhs_function,
+ Vector<double> &rhs_vector,
const std::set<types::boundary_id> &boundary_ids)
{
create_boundary_right_hand_side(hp::StaticMappingQ1<dim>::mapping_collection,
template <typename number>
- void invert_mass_matrix(const SparseMatrix<number> &mass_matrix,
+ void invert_mass_matrix(const SparseMatrix<number> &mass_matrix,
const FilteredMatrix<Vector<number> > &filtered_mass_matrix,
- FilteredMatrix<Vector<number> > &filtered_preconditioner,
- const Vector<number> &rhs,
- Vector<number> &boundary_projection)
+ FilteredMatrix<Vector<number> > &filtered_preconditioner,
+ const Vector<number> &rhs,
+ Vector<number> &boundary_projection)
{
// Allow for a maximum of 5*n steps to reduce the residual by 10^-12. n
// steps may not be sufficient, since roundoff errors may accumulate for
}
template <typename number>
- void invert_mass_matrix(const SparseMatrix<std::complex<number> > &/*mass_matrix*/,
- const FilteredMatrix<Vector<std::complex<number> > > &/*filtered_mass_matrix*/,
- FilteredMatrix<Vector<std::complex<number> > > &/*filtered_preconditioner*/,
- const Vector<std::complex<number> > &/*rhs*/,
- Vector<std::complex<number> > &/*boundary_projection*/)
+ void invert_mass_matrix
+ (const SparseMatrix<std::complex<number> > &/*mass_matrix*/,
+ const FilteredMatrix<Vector<std::complex<number> > > &/*filtered_mass_matrix*/,
+ FilteredMatrix<Vector<std::complex<number> > > &/*filtered_preconditioner*/,
+ const Vector<std::complex<number> > &/*rhs*/,
+ Vector<std::complex<number> > &/*boundary_projection*/)
{
Assert(false, ExcNotImplemented());
}
template <int dim, int spacedim, template <int, int> class DoFHandlerType,
template <int,int> class M_or_MC, template <int> class Q_or_QC, typename number>
void
- do_project_boundary_values (const M_or_MC<dim, spacedim> &mapping,
- const DoFHandlerType<dim, spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Q_or_QC<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ do_project_boundary_values
+ (const M_or_MC<dim, spacedim> &mapping,
+ const DoFHandlerType<dim, spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Q_or_QC<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
// in 1d, projection onto the 0d end points == interpolation
if (dim == 1)
template <int dim, int spacedim, typename number>
void
- project_boundary_values (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim, spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ project_boundary_values
+ (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
do_project_boundary_values(mapping, dof, boundary_functions, q,
boundary_values, component_mapping);
template <int dim, int spacedim, typename number>
void
- project_boundary_values (const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ project_boundary_values
+ (const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
project_boundary_values(StaticMappingQ1<dim,spacedim>::mapping, dof, boundary_functions, q,
boundary_values, component_mapping);
template <int dim, int spacedim, typename number>
- void project_boundary_values (const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const hp::QCollection<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ void project_boundary_values
+ (const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const hp::QCollection<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
do_project_boundary_values (mapping, dof,
boundary_functions,
template <int dim, int spacedim, typename number>
- void project_boundary_values (const hp::DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
- const hp::QCollection<dim-1> &q,
- std::map<types::global_dof_index,number> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ void project_boundary_values
+ (const hp::DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_function,
+ const hp::QCollection<dim-1> &q,
+ std::map<types::global_dof_index,number> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
project_boundary_values (hp::StaticMappingQ1<dim,spacedim>::mapping_collection, dof,
boundary_function,
template <int dim, int spacedim, typename number>
void
- project_boundary_values (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- ConstraintMatrix &constraints,
- std::vector<unsigned int> component_mapping)
+ project_boundary_values
+ (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ ConstraintMatrix &constraints,
+ std::vector<unsigned int> component_mapping)
{
std::map<types::global_dof_index,number> boundary_values;
project_boundary_values (mapping, dof, boundary_functions, q,
template <int dim, int spacedim, typename number>
void
- project_boundary_values (const DoFHandler<dim,spacedim> &dof,
- const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
- const Quadrature<dim-1> &q,
- ConstraintMatrix &constraints,
- std::vector<unsigned int> component_mapping)
+ project_boundary_values
+ (const DoFHandler<dim,spacedim> &dof,
+ const std::map<types::boundary_id, const Function<spacedim,number>*> &boundary_functions,
+ const Quadrature<dim-1> &q,
+ ConstraintMatrix &constraints,
+ std::vector<unsigned int> component_mapping)
{
project_boundary_values(StaticMappingQ1<dim,spacedim>::mapping, dof, boundary_functions, q,
constraints, component_mapping);
template <int dim>
- std::ostream &operator << (std::ostream &out,
+ std::ostream &operator << (std::ostream &out,
const VectorDoFTuple<dim> &vdt)
{
for (unsigned int d=0; d<dim; ++d)
add_constraint (const VectorDoFTuple<dim> &dof_indices,
const Tensor<1,dim> &constraining_vector,
ConstraintMatrix &constraints,
- const double inhomogeneity=0)
+ const double inhomogeneity=0)
{
// choose the DoF that has the
template<typename cell_iterator>
void
compute_edge_projection (const cell_iterator &cell,
- const unsigned int face,
- const unsigned int line,
- hp::FEValues<3> &hp_fe_values,
- const Function<3> &boundary_function,
- const unsigned int first_vector_component,
+ const unsigned int face,
+ const unsigned int line,
+ hp::FEValues<3> &hp_fe_values,
+ const Function<3> &boundary_function,
+ const unsigned int first_vector_component,
std::vector<double> &dof_values,
- std::vector<bool> &dofs_processed)
+ std::vector<bool> &dofs_processed)
{
const double tol = 0.5 * cell->face (face)->line (line)->diameter () / cell->get_fe ().degree;
const unsigned int dim = 3;
template<int dim, typename cell_iterator>
void
compute_face_projection_curl_conforming (const cell_iterator &cell,
- const unsigned int face,
- hp::FEValues<dim> &hp_fe_values,
+ const unsigned int face,
+ hp::FEValues<dim> &hp_fe_values,
const Function<dim> &boundary_function,
- const unsigned int first_vector_component,
+ const unsigned int first_vector_component,
std::vector<double> &dof_values,
- std::vector<bool> &dofs_processed)
+ std::vector<bool> &dofs_processed)
{
const unsigned int spacedim = dim;
hp_fe_values.reinit (cell, cell->active_fe_index ()
template <int dim>
void
- project_boundary_values_curl_conforming (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping)
+ project_boundary_values_curl_conforming (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping)
{
// Projection-based interpolation is performed in two (in 2D) respectively
// three (in 3D) steps. First the tangential component of the function is
template <int dim>
void
- project_boundary_values_curl_conforming (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim> &mapping_collection)
+ project_boundary_values_curl_conforming
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim> &mapping_collection)
{
hp::FECollection<dim> fe_collection (dof_handler.get_fe ());
hp::QCollection<dim> face_quadrature_collection;
template<typename cell_iterator>
void
compute_edge_projection_l2 (const cell_iterator &cell,
- const unsigned int face,
- const unsigned int line,
- hp::FEValues<3> &hp_fe_values,
- const Function<3> &boundary_function,
- const unsigned int first_vector_component,
+ const unsigned int face,
+ const unsigned int line,
+ hp::FEValues<3> &hp_fe_values,
+ const Function<3> &boundary_function,
+ const unsigned int first_vector_component,
std::vector<double> &dof_values,
- std::vector<bool> &dofs_processed)
+ std::vector<bool> &dofs_processed)
{
// This function computes the L2-projection of the given
// boundary function on 3D edges and returns the constraints
template<int dim, typename cell_iterator>
void
- compute_face_projection_curl_conforming_l2 (const cell_iterator &cell,
- const unsigned int face,
- hp::FEFaceValues<dim> &hp_fe_face_values,
- const Function<dim> &boundary_function,
- const unsigned int first_vector_component,
- std::vector<double> &dof_values,
- std::vector<bool> &dofs_processed)
+ compute_face_projection_curl_conforming_l2
+ (const cell_iterator &cell,
+ const unsigned int face,
+ hp::FEFaceValues<dim> &hp_fe_face_values,
+ const Function<dim> &boundary_function,
+ const unsigned int first_vector_component,
+ std::vector<double> &dof_values,
+ std::vector<bool> &dofs_processed)
{
// This function computes the L2-projection of the boundary
// function on the interior of faces only. In 3D, this should only be
template <int dim>
void
- project_boundary_values_curl_conforming_l2 (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping)
+ project_boundary_values_curl_conforming_l2
+ (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping)
{
// non-hp version - calls the internal
// compute_project_boundary_values_curl_conforming_l2() function
template <int dim>
void
- project_boundary_values_curl_conforming_l2 (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim, dim> &mapping_collection)
+ project_boundary_values_curl_conforming_l2
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim, dim> &mapping_collection)
{
// hp version - calls the internal
// compute_project_boundary_values_curl_conforming_l2() function above.
// boundary in 2d.
template <typename cell_iterator>
void
- compute_face_projection_div_conforming (const cell_iterator &cell,
- const unsigned int face,
- const FEFaceValues<2> &fe_values,
- const unsigned int first_vector_component,
- const Function<2> &boundary_function,
- const std::vector<DerivativeForm<1,2,2> > &jacobians,
- ConstraintMatrix &constraints)
+ compute_face_projection_div_conforming
+ (const cell_iterator &cell,
+ const unsigned int face,
+ const FEFaceValues<2> &fe_values,
+ const unsigned int first_vector_component,
+ const Function<2> &boundary_function,
+ const std::vector<DerivativeForm<1,2,2> > &jacobians,
+ ConstraintMatrix &constraints)
{
// Compute the intergral over the product of the normal components of
// the boundary function times the normal components of the shape
// boundary in 3d.
template<typename cell_iterator>
void
- compute_face_projection_div_conforming (const cell_iterator &cell,
- const unsigned int face,
- const FEFaceValues<3> &fe_values,
- const unsigned int first_vector_component,
- const Function<3> &boundary_function,
- const std::vector<DerivativeForm<1,3,3> > &jacobians,
- std::vector<double> &dof_values,
- std::vector<types::global_dof_index> &projected_dofs)
+ compute_face_projection_div_conforming
+ (const cell_iterator &cell,
+ const unsigned int face,
+ const FEFaceValues<3> &fe_values,
+ const unsigned int first_vector_component,
+ const Function<3> &boundary_function,
+ const std::vector<DerivativeForm<1,3,3> > &jacobians,
+ std::vector<double> &dof_values,
+ std::vector<types::global_dof_index> &projected_dofs)
{
// Compute the intergral over the product of the normal components of
// the boundary function times the normal components of the shape
template <int dim>
void
- project_boundary_values_div_conforming (const DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const Mapping<dim> &mapping)
+ project_boundary_values_div_conforming (const DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const Mapping<dim> &mapping)
{
const unsigned int spacedim = dim;
// Interpolate the normal components
template <int dim>
void
- project_boundary_values_div_conforming (const hp::DoFHandler<dim> &dof_handler,
- const unsigned int first_vector_component,
- const Function<dim> &boundary_function,
- const types::boundary_id boundary_component,
- ConstraintMatrix &constraints,
- const hp::MappingCollection<dim, dim> &mapping_collection)
+ project_boundary_values_div_conforming
+ (const hp::DoFHandler<dim> &dof_handler,
+ const unsigned int first_vector_component,
+ const Function<dim> &boundary_function,
+ const types::boundary_id boundary_component,
+ ConstraintMatrix &constraints,
+ const hp::MappingCollection<dim, dim> &mapping_collection)
{
const unsigned int spacedim = dim;
const hp::FECollection<dim> &fe_collection = dof_handler.get_fe ();
template <int dim, class InVector, class OutVector, int spacedim>
void
- integrate_difference (const Mapping<dim, spacedim> &mapping,
+ integrate_difference (const Mapping<dim, spacedim> &mapping,
const DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim> &exact_solution,
- OutVector &difference,
- const Quadrature<dim> &q,
- const NormType &norm,
- const Function<spacedim> *weight,
- const double exponent)
+ const InVector &fe_function,
+ const Function<spacedim> &exact_solution,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
+ const double exponent)
{
internal
::do_integrate_difference (hp::MappingCollection<dim,spacedim>(mapping),
template <int dim, class InVector, class OutVector, int spacedim>
void
- integrate_difference (const DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim> &exact_solution,
- OutVector &difference,
- const Quadrature<dim> &q,
- const NormType &norm,
- const Function<spacedim> *weight,
- const double exponent)
+ integrate_difference (const DoFHandler<dim,spacedim> &dof,
+ const InVector &fe_function,
+ const Function<spacedim> &exact_solution,
+ OutVector &difference,
+ const Quadrature<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
+ const double exponent)
{
internal
::do_integrate_difference(hp::StaticMappingQ1<dim,spacedim>::mapping_collection,
template <int dim, class InVector, class OutVector, int spacedim>
void
- integrate_difference (const dealii::hp::MappingCollection<dim,spacedim> &mapping,
- const dealii::hp::DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim> &exact_solution,
- OutVector &difference,
- const dealii::hp::QCollection<dim> &q,
- const NormType &norm,
- const Function<spacedim> *weight,
- const double exponent)
+ integrate_difference (const dealii::hp::MappingCollection<dim,spacedim> &mapping,
+ const dealii::hp::DoFHandler<dim,spacedim> &dof,
+ const InVector &fe_function,
+ const Function<spacedim> &exact_solution,
+ OutVector &difference,
+ const dealii::hp::QCollection<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
+ const double exponent)
{
internal
::do_integrate_difference (hp::MappingCollection<dim,spacedim>(mapping),
template <int dim, class InVector, class OutVector, int spacedim>
void
- integrate_difference (const dealii::hp::DoFHandler<dim,spacedim> &dof,
- const InVector &fe_function,
- const Function<spacedim> &exact_solution,
- OutVector &difference,
- const dealii::hp::QCollection<dim> &q,
- const NormType &norm,
- const Function<spacedim> *weight,
- const double exponent)
+ integrate_difference (const dealii::hp::DoFHandler<dim,spacedim> &dof,
+ const InVector &fe_function,
+ const Function<spacedim> &exact_solution,
+ OutVector &difference,
+ const dealii::hp::QCollection<dim> &q,
+ const NormType &norm,
+ const Function<spacedim> *weight,
+ const double exponent)
{
internal
::do_integrate_difference(hp::StaticMappingQ1<dim,spacedim>::mapping_collection,
template <int dim, int spacedim, class InVector>
double compute_global_error(const Triangulation<dim,spacedim> &tria,
- const InVector &cellwise_error,
- const NormType &norm,
- const double exponent)
+ const InVector &cellwise_error,
+ const NormType &norm,
+ const double exponent)
{
Assert( cellwise_error.size() == tria.n_active_cells(),
ExcMessage("input vector cell_error has invalid size!"));
template <int dim, typename VectorType, int spacedim>
void
- point_difference (const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Function<spacedim, typename VectorType::value_type> &exact_function,
- Vector<typename VectorType::value_type> &difference,
- const Point<spacedim> &point)
+ point_difference (const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Function<spacedim, typename VectorType::value_type> &exact_function,
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point)
{
point_difference(StaticMappingQ1<dim>::mapping,
dof,
template <int dim, typename VectorType, int spacedim>
void
- point_difference (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Function<spacedim, typename VectorType::value_type> &exact_function,
- Vector<typename VectorType::value_type> &difference,
- const Point<spacedim> &point)
+ point_difference (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Function<spacedim, typename VectorType::value_type> &exact_function,
+ Vector<typename VectorType::value_type> &difference,
+ const Point<spacedim> &point)
{
typedef typename VectorType::value_type Number;
const FiniteElement<dim> &fe = dof.get_fe();
template <int dim, typename VectorType, int spacedim>
void
- point_value (const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value)
+ point_value (const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value)
{
point_value (StaticMappingQ1<dim,spacedim>::mapping,
template <int dim, typename VectorType, int spacedim>
void
- point_value (const hp::DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value)
+ point_value (const hp::DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value)
{
point_value(hp::StaticMappingQ1<dim,spacedim>::mapping_collection,
dof,
template <int dim, typename VectorType, int spacedim>
void
- point_value (const Mapping<dim, spacedim> &mapping,
- const DoFHandler<dim,spacedim> &dof,
- const VectorType &fe_function,
- const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value)
+ point_value (const Mapping<dim, spacedim> &mapping,
+ const DoFHandler<dim,spacedim> &dof,
+ const VectorType &fe_function,
+ const Point<spacedim> &point,
+ Vector<typename VectorType::value_type> &value)
{
typedef typename VectorType::value_type Number;
const FiniteElement<dim> &fe = dof.get_fe();
const hp::DoFHandler<dim,spacedim> &dof,
const VectorType &fe_function,
const Point<spacedim> &point,
- Vector<typename VectorType::value_type> &value)
+ Vector<typename VectorType::value_type> &value)
{
typedef typename VectorType::value_type Number;
const hp::FECollection<dim, spacedim> &fe = dof.get_fe();
const DoFHandler<dim,spacedim> &dof,
const Quadrature<dim> &quadrature,
const VectorType &v,
- const unsigned int component)
+ const unsigned int component)
{
typedef typename VectorType::value_type Number;
Assert (v.size() == dof.n_dofs(),
compute_mean_value (const DoFHandler<dim,spacedim> &dof,
const Quadrature<dim> &quadrature,
const VectorType &v,
- const unsigned int component)
+ const unsigned int component)
{
return compute_mean_value(StaticMappingQ1<dim,spacedim>::mapping, dof, quadrature, v, component);
}