* Reference to the stream we
* want to write to.
*/
- std::ostream &output_stream;
+ std::ostream &output_stream;
/**
* Stores the actual condition
* @author Marco Engelhard, 2012
*/
void write_pvd_record (std::ostream &out,
- const std::vector<std::pair<double,std::string> > ×_and_names) const;
+ const std::vector<std::pair<double,std::string> > ×_and_names) const;
/**
* This function is the exact
/**
* Name of the file this exception happen in.
*/
- const char *file;
+ const char *file;
/**
* Line number in this file.
/**
* Name of the function, pretty printed.
*/
- const char *function;
+ const char *function;
/**
* The violated condition, as a string.
*/
- const char *cond;
+ const char *cond;
/**
* Name of the exception and call sequence.
*/
- const char *exc;
+ const char *exc;
/**
* A backtrace to the position where the problem happened, if the
template <int dim>
inline
Point<dim>
-GeometryInfo<dim>::cell_to_child_coordinates (const Point<dim> &/*p*/,
+GeometryInfo<dim>::cell_to_child_coordinates (const Point<dim> & /*p*/,
const unsigned int /*child_index*/,
const RefinementCase<dim> /*refine_case*/)
template <int dim>
inline
Point<dim>
-GeometryInfo<dim>::child_to_cell_coordinates (const Point<dim> &/*p*/,
+GeometryInfo<dim>::child_to_cell_coordinates (const Point<dim> & /*p*/,
const unsigned int /*child_index*/,
const RefinementCase<dim> /*refine_case*/)
{
* to <tt>std::cerr</tt>, but can be set to another
* stream through the constructor.
*/
- std::ostream *std_out;
+ std::ostream *std_out;
/**
* Pointer to a stream, where a copy of
* You can set and reset this stream
* by the <tt>attach</tt> function.
*/
- std::ostream *file;
+ std::ostream *file;
/**
* Value denoting the number of
*/
template <typename RangeType, typename Function>
void apply_to_subranges (const tbb::blocked_range<RangeType> &range,
- const Function &f)
+ const Function &f)
{
f (range.begin(), range.end());
}
* and maximal allowable
* lengths of the list.
*/
- List (const PatternBase &base_pattern,
+ List (const PatternBase &base_pattern,
const unsigned int min_elements = 0,
const unsigned int max_elements = max_int_value);
* and maximal allowable
* lengths of the list.
*/
- Map (const PatternBase &key_pattern,
- const PatternBase &value_pattern,
+ Map (const PatternBase &key_pattern,
+ const PatternBase &value_pattern,
const unsigned int min_elements = 0,
const unsigned int max_elements = max_int_value);
inline
- const IndexSet &Partitioner::ghost_indices() const
+ const IndexSet &Partitioner::ghost_indices() const
{
return ghost_indices_data;
}
static void project_to_subface (const SubQuadrature &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
- std::vector<Point<dim> > &q_points,
+ std::vector<Point<dim> > &q_points,
const RefinementCase<dim-1> &ref_case=RefinementCase<dim-1>::isotropic_refinement);
/**
*/
static
Quadrature<dim>
- project_to_child (const Quadrature<dim> &quadrature,
+ project_to_child (const Quadrature<dim> &quadrature,
const unsigned int child_no);
/**
*/
static
Quadrature<dim>
- project_to_all_children (const Quadrature<dim> &quadrature);
+ project_to_all_children (const Quadrature<dim> &quadrature);
/**
* Project the onedimensional
* want to change the pointer
* variable which we are given.
*/
- void swap (T *&tt);
+ void swap (T *&tt);
/**
* Return an estimate of the
template <typename T, typename P>
inline
-void SmartPointer<T,P>::swap (T *&tt)
+void SmartPointer<T,P>::swap (T *&tt)
{
if (t != 0)
t->unsubscribe (id);
*/
template <typename T, typename P>
inline
-void swap (SmartPointer<T,P> &t1, T *&t2)
+void swap (SmartPointer<T,P> &t1, T *&t2)
{
t1.swap (t2);
}
*/
template <typename T, typename P>
inline
-void swap (T *&t1, SmartPointer<T,P> &t2)
+void swap (T *&t1, SmartPointer<T,P> &t2)
{
t2.swap (t1);
}
Iterator
lower_bound (Iterator first,
Iterator last,
- const T &val);
+ const T &val);
/**
* the duplicate_communicator() function.
*/
Epetra_Map
- duplicate_map (const Epetra_BlockMap &map,
+ duplicate_map (const Epetra_BlockMap &map,
const Epetra_Comm &comm);
}
Iterator
lower_bound (Iterator first,
Iterator last,
- const T &val)
+ const T &val)
{
return Utilities::lower_bound (first, last, val,
std::less<T>());
* function.
*/
template <int dim, int spacedim>
- static void hyper_cube (Triangulation<dim,spacedim> &tria,
+ static void hyper_cube (Triangulation<dim,spacedim> &tria,
const double left = 0.,
const double right= 1.);
* function.
*/
template <int dim>
- static void subdivided_hyper_cube (Triangulation<dim> &tria,
+ static void subdivided_hyper_cube (Triangulation<dim> &tria,
const unsigned int repetitions,
const double left = 0.,
const double right= 1.);
*/
template <int dim>
static void
- parallelogram(Triangulation<dim> &tria,
+ parallelogram(Triangulation<dim> &tria,
const Tensor<2,dim> &corners,
const bool colorize=false);
* torus.
*/
- static void torus (Triangulation<2,3> &tria,
+ static void torus (Triangulation<2,3> &tria,
const double R,
const double r);
* @param R The radius of the circle, which forms the middle line of the torus containing the loop of cells. Must be greater than @p r.
* @param r The radius of the cylinder bend together as loop.
*/
- static void moebius (Triangulation<3,3> &tria,
+ static void moebius (Triangulation<3,3> &tria,
const unsigned int n_cells,
const unsigned int n_rotations,
const double R,
*/
static void parse_tecplot_header(std::string &header,
std::vector<unsigned int> &tecplot2deal,
- unsigned int &n_vars,
- unsigned int &n_vertices,
- unsigned int &n_cells,
+ unsigned int &n_vars,
+ unsigned int &n_vertices,
+ unsigned int &n_cells,
std::vector<unsigned int> &IJK,
bool &structured,
bool &blocked);
const unsigned int s1,
const unsigned int s2,
const unsigned int s3,
- const CellData<2> &cd);
+ const CellData<2> &cd);
/**
* Stores the vertex numbers
*/
template <int dim, template <int,int> class Container, int spacedim>
typename Container<dim,spacedim>::active_cell_iterator
- find_active_cell_around_point (const Container<dim,spacedim> &container,
+ find_active_cell_around_point (const Container<dim,spacedim> &container,
const Point<spacedim> &p);
/**
*/
template <int dim, int spacedim>
void
- get_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
+ get_subdomain_association (const Triangulation<dim, spacedim> &triangulation,
std::vector<types::subdomain_id> &subdomain);
/**
Point<3>
StraightBoundary<1,3>::
project_to_surface (const Triangulation<1, 3>::quad_iterator &quad,
- const Point<3> &y) const;
+ const Point<3> &y) const;
#endif // DOXYGEN
*/
template <class BlockVectorType,
class VectorType>
- void Tvmult_block_nonblock (BlockVectorType &dst,
+ void Tvmult_block_nonblock (BlockVectorType &dst,
const VectorType &src) const;
/**
template <class BlockMatrix>
inline
Accessor<BlockMatrix, true>::Accessor (
- const BlockMatrix *matrix,
+ const BlockMatrix *matrix,
const unsigned int row,
const unsigned int col)
:
template <class BlockMatrix>
inline
Accessor<BlockMatrix, false>::Accessor (
- BlockMatrix *matrix,
+ BlockMatrix *matrix,
const unsigned int row,
const unsigned int col)
:
void
BlockMatrixBase<MatrixType>::add (const unsigned int row,
const unsigned int n_cols,
- const unsigned int *col_indices,
+ const unsigned int *col_indices,
const number *values,
const bool elide_zero_values,
const bool col_indices_are_sorted)
class VectorType>
void
BlockMatrixBase<MatrixType>::
-vmult_block_nonblock (BlockVectorType &dst,
+vmult_block_nonblock (BlockVectorType &dst,
const VectorType &src) const
{
Assert (dst.n_blocks() == n_block_rows(),
class VectorType>
void
BlockMatrixBase<MatrixType>::
-Tvmult_block_nonblock (BlockVectorType &dst,
+Tvmult_block_nonblock (BlockVectorType &dst,
const VectorType &src) const
{
Assert (dst.n_blocks() == n_block_cols(),
void
MatrixBlock<MATRIX>::add (const unsigned int b_row,
const unsigned int n_cols,
- const unsigned int *col_indices,
+ const unsigned int *col_indices,
const number *values,
const bool,
const bool)
* in_vector, and copies all the data.
*/
Vector<Number> &
- operator = (const Vector<Number> &in_vector);
+ operator = (const Vector<Number> &in_vector);
/**
* Assigns the vector to the parallel
*/
template <typename OtherNumber>
void add (const std::vector<unsigned int> &indices,
- const std::vector<OtherNumber> &values);
+ const std::vector<OtherNumber> &values);
/**
* This is a second collective
template <typename OtherNumber>
void add (const unsigned int n_elements,
const unsigned int *indices,
- const OtherNumber *values);
+ const OtherNumber *values);
/**
* Addition of @p s to all
inline
void
Vector<Number>::add (const std::vector<unsigned int> &indices,
- const std::vector<OtherNumber> &values)
+ const std::vector<OtherNumber> &values)
{
AssertDimension (indices.size(), values.size());
add (indices.size(), &indices[0], &values[0]);
void
Vector<Number>::add (const unsigned int n_indices,
const unsigned int *indices,
- const OtherNumber *values)
+ const OtherNumber *values)
{
for (unsigned int i=0; i<n_indices; ++i)
{
* applicable if the matrix has
* only one block row.
*/
- void Tvmult (BlockVector &dst,
+ void Tvmult (BlockVector &dst,
const Vector &src) const;
/**
inline
void
- BlockSparseMatrix::vmult (BlockVector &dst,
+ BlockSparseMatrix::vmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::vmult_block_nonblock (dst, src);
inline
void
- BlockSparseMatrix::Tvmult (BlockVector &dst,
+ BlockSparseMatrix::Tvmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::Tvmult_block_nonblock (dst, src);
* that of V, all components are copied
* from V
*/
- BlockVector (const BlockVector &V);
+ BlockVector (const BlockVector &V);
/**
* Copy-constructor: copy the values
* applicable if the matrix has
* only one block row.
*/
- void Tvmult (BlockVector &dst,
+ void Tvmult (BlockVector &dst,
const Vector &src) const;
/**
inline
void
- BlockSparseMatrix::vmult (BlockVector &dst,
+ BlockSparseMatrix::vmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::vmult_block_nonblock (dst, src);
inline
void
- BlockSparseMatrix::Tvmult (BlockVector &dst,
+ BlockSparseMatrix::Tvmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::Tvmult_block_nonblock (dst, src);
* not provide for nonzero entries on the entire diagonal.
*/
SparseMatrix (const SparsityPattern &sparsity,
- const IdentityMatrix &id);
+ const IdentityMatrix &id);
/**
* Destructor. Free all memory, but do not release the memory of the
* provide for nonzero entries on the entire diagonal.
*/
SparseMatrix<number> &
- operator= (const IdentityMatrix &id);
+ operator= (const IdentityMatrix &id);
/**
* This operator assigns a scalar to a matrix. Since this does usually not
* matrix structure. It must be compressed. The matrix structure is not
* compressed after this function finishes.
*/
- SparsityPattern (const SparsityPattern &original,
+ SparsityPattern (const SparsityPattern &original,
const unsigned int max_per_row,
const unsigned int extra_off_diagonals);
* applicable if the matrix has
* only one block column.
*/
- void vmult (MPI::BlockVector &dst,
+ void vmult (MPI::BlockVector &dst,
const MPI::Vector &src) const;
/**
* (works only when run on one
* processor).
*/
- void vmult (BlockVector &dst,
+ void vmult (BlockVector &dst,
const Vector &src) const;
/**
* applicable if the matrix has
* only one block row.
*/
- void Tvmult (MPI::BlockVector &dst,
+ void Tvmult (MPI::BlockVector &dst,
const MPI::Vector &src) const;
/**
* vectors (works only when run
* on one processor).
*/
- void Tvmult (BlockVector &dst,
+ void Tvmult (BlockVector &dst,
const Vector &src) const;
/**
inline
void
- BlockSparseMatrix::vmult (MPI::BlockVector &dst,
+ BlockSparseMatrix::vmult (MPI::BlockVector &dst,
const MPI::Vector &src) const
{
BaseClass::vmult_block_nonblock (dst, src);
inline
void
- BlockSparseMatrix::vmult (BlockVector &dst,
+ BlockSparseMatrix::vmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::vmult_block_nonblock (dst, src);
inline
void
- BlockSparseMatrix::Tvmult (MPI::BlockVector &dst,
+ BlockSparseMatrix::Tvmult (MPI::BlockVector &dst,
const MPI::Vector &src) const
{
BaseClass::Tvmult_block_nonblock (dst, src);
inline
void
- BlockSparseMatrix::Tvmult (BlockVector &dst,
+ BlockSparseMatrix::Tvmult (BlockVector &dst,
const Vector &src) const
{
BaseClass::Tvmult_block_nonblock (dst, src);
* values in the second.
*/
void set (const std::vector<unsigned int> &indices,
- const std::vector<TrilinosScalar> &values);
+ const std::vector<TrilinosScalar> &values);
/**
* This is a second collective
inline
void
VectorBase::set (const std::vector<unsigned int> &indices,
- const std::vector<TrilinosScalar> &values)
+ const std::vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
// writing to this vector at all.
inline
void
VectorBase::add (const std::vector<unsigned int> &indices,
- const std::vector<TrilinosScalar> &values)
+ const std::vector<TrilinosScalar> &values)
{
// if we have ghost values, do not allow
// writing to this vector at all.
*/
template <typename OtherNumber>
void add (const std::vector<unsigned int> &indices,
- const std::vector<OtherNumber> &values);
+ const std::vector<OtherNumber> &values);
/**
* This is a second collective
template <typename OtherNumber>
void add (const unsigned int n_elements,
const unsigned int *indices,
- const OtherNumber *values);
+ const OtherNumber *values);
/**
* Addition of @p s to all
inline
void
Vector<Number>::add (const std::vector<unsigned int> &indices,
- const std::vector<OtherNumber> &values)
+ const std::vector<OtherNumber> &values)
{
Assert (indices.size() == values.size(),
ExcDimensionMismatch(indices.size(), values.size()));
void
Vector<Number>::add (const unsigned int n_indices,
const unsigned int *indices,
- const OtherNumber *values)
+ const OtherNumber *values)
{
for (unsigned int i=0; i<n_indices; ++i)
{
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
-::distribute_local_to_global (std::vector<VectorType> &dst,
+::distribute_local_to_global (std::vector<VectorType> &dst,
const unsigned int first_index) const
{
AssertIndexRange (first_index, dst.size());
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
-::distribute_local_to_global (std::vector<VectorType *> &dst,
+::distribute_local_to_global (std::vector<VectorType *> &dst,
const unsigned int first_index) const
{
AssertIndexRange (first_index, dst.size());
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
-::set_dof_values (std::vector<VectorType> &dst,
+::set_dof_values (std::vector<VectorType> &dst,
const unsigned int first_index) const
{
AssertIndexRange (first_index, dst.size());
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
-::set_dof_values (std::vector<VectorType *> &dst,
+::set_dof_values (std::vector<VectorType *> &dst,
const unsigned int first_index) const
{
AssertIndexRange (first_index, dst.size());
const std::vector<std::pair<unsigned int,unsigned int> > &cells,
const std::vector<unsigned int> &active_fe_index,
const Mapping<dim> &mapping,
- const std::vector<dealii::hp::QCollection<1> > &quad,
+ const std::vector<dealii::hp::QCollection<1> > &quad,
const UpdateFlags update_flags);
/**
*/
UpdateFlags
compute_update_flags (const UpdateFlags update_flags,
- const std::vector<dealii::hp::QCollection<1> > &quad) const;
+ const std::vector<dealii::hp::QCollection<1> > &quad) const;
/**
* Returns the type of a given cell as
if (pc != 0)
fevalv[i] = std_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
- new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
- pc->get_quadrature(), pc->get_update_flags()));
+ new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
+ pc->get_quadrature(), pc->get_update_flags()));
else if (pf != 0)
fevalv[i] = std_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
new FEFaceValues<dim,sdim> (pf->get_mapping(), pf->get_fe(), pf->get_quadrature(), pf->get_update_flags()));
if (pc != 0)
fevalv[i] = std_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
- new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
- pc->get_quadrature(), pc->get_update_flags()));
+ new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
+ pc->get_quadrature(), pc->get_update_flags()));
else if (pf != 0)
{
Assert (false, ExcImpossibleInDim(1));
if (pc != 0)
fevalv[i] = std_cxx1x::shared_ptr<FEValuesBase<dim,sdim> > (
- new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
- pc->get_quadrature(), pc->get_update_flags()));
+ new FEValues<dim,sdim> (pc->get_mapping(), pc->get_fe(),
+ pc->get_quadrature(), pc->get_update_flags()));
else if (pf != 0)
{
Assert (false, ExcImpossibleInDim(1));
template<class MATRIX, class PRECOND>
MGCoarseGridLACIteration<SOLVER, VECTOR>
::MGCoarseGridLACIteration(SOLVER &s,
- const MATRIX &m,
+ const MATRIX &m,
const PRECOND &p)
:
solver(&s, typeid(*this).name())
void
MGCoarseGridLACIteration<SOLVER, VECTOR>
::initialize(SOLVER &s,
- const MATRIX &m,
+ const MATRIX &m,
const PRECOND &p)
{
solver = &s;
*/
template <class InputVector, int spacedim>
static ProjectedDerivative
- get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
+ get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
const InputVector &solution,
const unsigned int component);
*/
template <class InputVector, int spacedim>
static ProjectedDerivative
- get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
+ get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
const InputVector &solution,
const unsigned int component);
*/
template <class InputVector, int spacedim>
static ProjectedDerivative
- get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
+ get_projected_derivative (const FEValues<dim,spacedim> &fe_values,
const InputVector &solution,
const unsigned int component);
const DH<dim,spacedim> &dof,
const InputVector &solution,
const unsigned int component,
- const typename DH<dim,spacedim>::active_cell_iterator &cell,
+ const typename DH<dim,spacedim>::active_cell_iterator &cell,
typename DerivativeDescription::Derivative &derivative);
};
* general case.
*/
template <typename InputVector, class DH>
- static void estimate (const Mapping<1,spacedim> &mapping,
+ static void estimate (const Mapping<1,spacedim> &mapping,
const DH &dof,
const Quadrature<0> &quadrature,
const typename FunctionMap<spacedim>::type &neumann_bc,
template <typename number>
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- SparseMatrix<number> &matrix,
+ SparseMatrix<number> &matrix,
Vector<number> &solution,
Vector<number> &right_hand_side,
const bool eliminate_columns = true);
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- PETScWrappers::SparseMatrix &matrix,
- PETScWrappers::Vector &solution,
- PETScWrappers::Vector &right_hand_side,
+ PETScWrappers::SparseMatrix &matrix,
+ PETScWrappers::Vector &solution,
+ PETScWrappers::Vector &right_hand_side,
const bool eliminate_columns = true);
/**
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- PETScWrappers::MPI::SparseMatrix &matrix,
- PETScWrappers::MPI::Vector &solution,
- PETScWrappers::MPI::Vector &right_hand_side,
+ PETScWrappers::MPI::SparseMatrix &matrix,
+ PETScWrappers::MPI::Vector &solution,
+ PETScWrappers::MPI::Vector &right_hand_side,
const bool eliminate_columns = true);
/**
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- PETScWrappers::MPI::SparseMatrix &matrix,
+ PETScWrappers::MPI::SparseMatrix &matrix,
PETScWrappers::Vector &solution,
- PETScWrappers::MPI::Vector &right_hand_side,
+ PETScWrappers::MPI::Vector &right_hand_side,
const bool eliminate_columns = true);
/**
* Same as above but for BlockSparseMatrix.
*/
void
- apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- PETScWrappers::MPI::BlockSparseMatrix &matrix,
+ apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
+ PETScWrappers::MPI::BlockSparseMatrix &matrix,
PETScWrappers::MPI::BlockVector &solution,
PETScWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns = true);
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- TrilinosWrappers::SparseMatrix &matrix,
+ TrilinosWrappers::SparseMatrix &matrix,
TrilinosWrappers::Vector &solution,
TrilinosWrappers::Vector &right_hand_side,
const bool eliminate_columns = true);
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- TrilinosWrappers::BlockSparseMatrix &matrix,
+ TrilinosWrappers::BlockSparseMatrix &matrix,
TrilinosWrappers::BlockVector &solution,
TrilinosWrappers::BlockVector &right_hand_side,
const bool eliminate_columns = true);
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- TrilinosWrappers::SparseMatrix &matrix,
+ TrilinosWrappers::SparseMatrix &matrix,
TrilinosWrappers::MPI::Vector &solution,
TrilinosWrappers::MPI::Vector &right_hand_side,
const bool eliminate_columns = true);
*/
void
apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
- TrilinosWrappers::BlockSparseMatrix &matrix,
+ TrilinosWrappers::BlockSparseMatrix &matrix,
TrilinosWrappers::MPI::BlockVector &solution,
TrilinosWrappers::MPI::BlockVector &right_hand_side,
const bool eliminate_columns = true);
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const VECTOR &u1,
const DH<dim, spacedim> &dof2,
- const ConstraintMatrix &constraints,
+ const ConstraintMatrix &constraints,
VECTOR &u2);
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const Vector &u1,
const DH<dim, spacedim> &dof2,
- const ConstraintMatrix &constraints,
+ const ConstraintMatrix &constraints,
Vector &u2)
{
Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
const DoFHandler<dim, spacedim> &dof,
const typename FunctionMap<spacedim>::type &boundary_functions,
const Quadrature<dim-1> &q,
- std::map<unsigned int,double> &boundary_values,
+ std::map<unsigned int,double> &boundary_values,
std::vector<unsigned int> component_mapping)
{
//TODO:[?] In project_boundary_values, no condensation of sparsity