namespace internal
{
- namespace Vector
+ namespace VectorImplementation
{
/**
* If we do computations on vectors in parallel (say, we add two vectors
}
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
/**
- * Like internal::Vector::minimum_parallel_grain_size, but now denoting
+ * Like internal::VectorImplementation::minimum_parallel_grain_size, but now denoting
* the number of rows of a matrix that should be worked on as a minimum.
*/
extern unsigned int minimum_parallel_grain_size;
namespace internal
{
- namespace PolynomialsRannacherTurek
+ namespace PolynomialsRannacherTurekImplementation
{
template <int order, int dim>
inline
PolynomialsRannacherTurek<dim>::compute_derivative (const unsigned int i,
const Point<dim> &p) const
{
- return internal::PolynomialsRannacherTurek::compute_derivative<order> (i, p);
+ return internal::PolynomialsRannacherTurekImplementation::compute_derivative<order> (i, p);
}
* A namespace for functions and classes that are internal to how the
* SymmetricTensor class (and its associate functions) works.
*/
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
/**
* Compute the inverse of a symmetric tensor of a
/**
* Make a few helper classes friends as well.
*/
- friend struct internal::SymmetricTensor::Inverse<2,dim,Number>;
+ friend struct internal::SymmetricTensorImplementation::Inverse<2,dim,Number>;
- friend struct internal::SymmetricTensor::Inverse<4,dim,Number>;
+ friend struct internal::SymmetricTensorImplementation::Inverse<4,dim,Number>;
};
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
template <int dim, typename Number>
dealii::Tensor<2,dim,Number>
SymmetricTensor<rank_,dim,Number>::
operator Tensor<rank_,dim,Number> () const
{
- return internal::SymmetricTensor::convert_to_tensor (*this);
+ return internal::SymmetricTensorImplementation::convert_to_tensor (*this);
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
template <int rank_>
TableIndices<rank_>
return
internal::SymmetricTensorAccessors::
Accessor<rank_,dim,true,rank_-1,Number> (*this,
- internal::SymmetricTensor::get_partially_filled_indices<rank_> (row,
+ internal::SymmetricTensorImplementation::get_partially_filled_indices<rank_> (row,
std::integral_constant<int, rank_>()));
}
return
internal::SymmetricTensorAccessors::
Accessor<rank_,dim,false,rank_-1,Number> (*this,
- internal::SymmetricTensor::get_partially_filled_indices<rank_> (row,
+ internal::SymmetricTensorImplementation::get_partially_filled_indices<rank_> (row,
std::integral_constant<int, rank_>()));
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
template <int dim, typename Number>
unsigned int
SymmetricTensor<rank_,dim,Number>::access_raw_entry (const unsigned int index) const
{
AssertIndexRange (index, n_independent_components);
- return data[internal::SymmetricTensor::entry_to_indices(*this, index)];
+ return data[internal::SymmetricTensorImplementation::entry_to_indices(*this, index)];
}
SymmetricTensor<rank_,dim,Number>::access_raw_entry (const unsigned int index)
{
AssertIndexRange (index, n_independent_components);
- return data[internal::SymmetricTensor::entry_to_indices(*this, index)];
+ return data[internal::SymmetricTensorImplementation::entry_to_indices(*this, index)];
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
namespace
{
SymmetricTensor<rank_,dim,Number>::component_to_unrolled_index
(const TableIndices<rank_> &indices)
{
- return internal::SymmetricTensor::component_to_unrolled_index<dim> (indices);
+ return internal::SymmetricTensorImplementation::component_to_unrolled_index<dim> (indices);
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
namespace
{
(const unsigned int i)
{
return
- internal::SymmetricTensor::unrolled_to_component_indices<dim> (i,
+ internal::SymmetricTensorImplementation::unrolled_to_component_indices<dim> (i,
std::integral_constant<int, rank_>());
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
/**
* Tridiagonalize a rank-2 symmetric tensor using the Householder method.
switch (method)
{
case SymmetricTensorEigenvectorMethod::hybrid:
- eig_vals_vecs = internal::SymmetricTensor::hybrid(T);
+ eig_vals_vecs = internal::SymmetricTensorImplementation::hybrid(T);
break;
case SymmetricTensorEigenvectorMethod::ql_implicit_shifts:
- eig_vals_vecs = internal::SymmetricTensor::ql_implicit_shifts(T);
+ eig_vals_vecs = internal::SymmetricTensorImplementation::ql_implicit_shifts(T);
break;
case SymmetricTensorEigenvectorMethod::jacobi:
- eig_vals_vecs = internal::SymmetricTensor::jacobi(T);
+ eig_vals_vecs = internal::SymmetricTensorImplementation::jacobi(T);
break;
default:
AssertThrow(false, ExcNotImplemented());
// Sort in descending order before output.
std::sort(eig_vals_vecs.begin(), eig_vals_vecs.end(),
- internal::SymmetricTensor::SortEigenValuesVectors<dim,Number>());
+ internal::SymmetricTensorImplementation::SortEigenValuesVectors<dim,Number>());
return eig_vals_vecs;
}
SymmetricTensor<2,dim,Number>
invert (const SymmetricTensor<2,dim,Number> &t)
{
- return internal::SymmetricTensor::Inverse<2,dim,Number>::value(t);
+ return internal::SymmetricTensorImplementation::Inverse<2,dim,Number>::value(t);
}
SymmetricTensor<4,dim,Number>
invert (const SymmetricTensor<4,dim,Number> &t)
{
- return internal::SymmetricTensor::Inverse<4,dim,Number>::value(t);
+ return internal::SymmetricTensorImplementation::Inverse<4,dim,Number>::value(t);
}
namespace internal
{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
{
template <int dim, typename Number>
void
namespace internal
{
- namespace Table
+ namespace TableImplementation
{
template <typename InputIterator, typename T>
void fill_Fortran_style (InputIterator entries,
p != values.end(); ++p)
*p = *entries++;
else
- internal::Table::fill_Fortran_style (entries, *this);
+ internal::TableImplementation::fill_Fortran_style (entries, *this);
}
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
namespace Policy
{
std::vector<bool>
mark_locally_active_vertices_on_level(const int level) const;
- template <typename> friend class dealii::internal::DoFHandler::Policy::ParallelDistributed;
+ template <typename> friend class dealii::internal::DoFHandlerImplementation::Policy::ParallelDistributed;
template <int,int,class> friend class dealii::FETools::internal::ExtrapolateImplementation;
};
namespace internal
{
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
struct Implementation;
}
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
namespace Policy
namespace hp
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
}
namespace internal
{
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
/**
* This is a switch class which only declares a @p typedef. It is meant to
* 2012, 2013
*/
template <int structdim, typename DoFHandlerType, bool level_dof_access>
-class DoFAccessor : public dealii::internal::DoFAccessor::Inheritance<structdim, DoFHandlerType::dimension, DoFHandlerType::space_dimension>::BaseClass
+class DoFAccessor : public dealii::internal::DoFAccessorImplementation::Inheritance<structdim, DoFHandlerType::dimension, DoFHandlerType::space_dimension>::BaseClass
{
public:
* exception classes simpler.
*/
typedef
- typename dealii::internal::DoFAccessor::Inheritance<structdim, dimension, space_dimension>::BaseClass
+ typename dealii::internal::DoFAccessorImplementation::Inheritance<structdim, dimension, space_dimension>::BaseClass
BaseClass;
/**
* a line itself, then the only valid index is @p i equals to zero, and the
* function returns an iterator to itself.
*/
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::line_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType, level_dof_access>::line_iterator
line (const unsigned int i) const;
/**
* a quad itself, then the only valid index is @p i equals to zero, and the
* function returns an iterator to itself.
*/
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
quad (const unsigned int i) const;
/**
template <int dim, int spacedim> friend class DoFHandler;
template <int dim, int spacedim> friend class hp::DoFHandler;
- friend struct dealii::internal::DoFHandler::Policy::Implementation;
- friend struct dealii::internal::DoFHandler::Implementation;
- friend struct dealii::internal::hp::DoFHandler::Implementation;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
- friend struct dealii::internal::DoFAccessor::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Policy::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::hp::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
+ friend struct dealii::internal::DoFAccessorImplementation::Implementation;
};
* Since meshes with dimension 1 do not have quads this method just throws
* an exception.
*/
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator
line (const unsigned int i) const;
/**
* Since meshes with dimension 1 do not have quads this method just throws
* an exception.
*/
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator
quad (const unsigned int i) const;
/**
template <int, int> friend class DoFHandler;
template <int, int> friend class hp::DoFHandler;
- friend struct dealii::internal::DoFHandler::Policy::Implementation;
- friend struct dealii::internal::DoFHandler::Implementation;
- friend struct dealii::internal::hp::DoFHandler::Implementation;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Policy::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::hp::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
};
* update_cell_dof_indices_cache() function
*/
template <int dim, int spacedim> friend class DoFHandler;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
};
const int index,
const DoFHandlerType *dof_handler)
:
- dealii::internal::DoFAccessor::Inheritance<structdim,DoFHandlerType::dimension,
+ dealii::internal::DoFAccessorImplementation::Inheritance<structdim,DoFHandlerType::dimension,
DoFHandlerType::space_dimension>::BaseClass (tria,
level,
index),
namespace internal
{
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
/**
* A class like the one with same name in tria.cc. See there for more
(structdim==1
?
typename
- internal::Triangulation::Iterators<dim,spacedim>::
+ internal::TriangulationImplementation::Iterators<dim,spacedim>::
raw_line_iterator (&dof_handler.get_triangulation(),
obj_level,
obj_index)->used()
(structdim==1
?
typename
- internal::Triangulation::Iterators<dim,spacedim>::
+ internal::TriangulationImplementation::Iterators<dim,spacedim>::
raw_line_iterator (&dof_handler.get_triangulation(),
obj_level,
obj_index)->used()
const unsigned int fe_index) const
{
// access the respective DoF
- return dealii::internal::DoFAccessor::Implementation::get_dof_index (*this->dof_handler,
+ return dealii::internal::DoFAccessorImplementation::Implementation::get_dof_index (*this->dof_handler,
this->level(),
this->present_index,
fe_index,
const unsigned int fe_index) const
{
// access the respective DoF
- dealii::internal::DoFAccessor::Implementation::set_dof_index (*this->dof_handler,
+ dealii::internal::DoFAccessorImplementation::Implementation::set_dof_index (*this->dof_handler,
this->level(),
this->present_index,
fe_index,
{
// access the respective DoF
return
- dealii::internal::DoFAccessor::Implementation::
+ dealii::internal::DoFAccessorImplementation::Implementation::
n_active_fe_indices (*this->dof_handler,
this->level(),
this->present_index,
{
// access the respective DoF
return
- dealii::internal::DoFAccessor::Implementation::
+ dealii::internal::DoFAccessorImplementation::Implementation::
nth_active_fe_index (*this->dof_handler,
this->level(),
this->present_index,
{
// access the respective DoF
return
- dealii::internal::DoFAccessor::Implementation::
+ dealii::internal::DoFAccessorImplementation::Implementation::
fe_index_is_active (*this->dof_handler,
this->level(),
this->present_index,
const unsigned int fe_index) const
{
return
- dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index
+ dealii::internal::DoFAccessorImplementation::Implementation::get_vertex_dof_index
(*this->dof_handler,
this->vertex_index(vertex),
fe_index,
ExcIndexRange (i, 0, this->dof_handler->get_fe (fe_index).dofs_per_vertex));
return
- dealii::internal::DoFAccessor::Implementation::mg_vertex_dof_index
+ dealii::internal::DoFAccessorImplementation::Implementation::mg_vertex_dof_index
(*this->dof_handler,
level,
this->vertex_index(vertex),
const types::global_dof_index index,
const unsigned int fe_index) const
{
- dealii::internal::DoFAccessor::Implementation::set_vertex_dof_index
+ dealii::internal::DoFAccessorImplementation::Implementation::set_vertex_dof_index
(*this->dof_handler,
this->vertex_index(vertex),
fe_index,
ExcIndexRange (i, 0, this->dof_handler->get_fe (fe_index).dofs_per_vertex));
return
- dealii::internal::DoFAccessor::Implementation::set_mg_vertex_dof_index
+ dealii::internal::DoFAccessorImplementation::Implementation::set_mg_vertex_dof_index
(*this->dof_handler,
level,
this->vertex_index(vertex),
namespace internal
{
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
template <typename DoFHandlerType, bool level_dof_access>
void get_dof_indices (const dealii::DoFAccessor<1,DoFHandlerType,level_dof_access> &accessor,
ExcInternalError());
// now do the actual work
- dealii::internal::DoFAccessor::get_dof_indices (*this, dof_indices, fe_index);
+ dealii::internal::DoFAccessorImplementation::get_dof_indices (*this, dof_indices, fe_index);
}
Assert (false, ExcNotImplemented ());
}
- internal::DoFAccessor::get_mg_dof_indices (*this,
- level,
- dof_indices,
- fe_index);
+ internal::DoFAccessorImplementation::get_mg_dof_indices (*this,
+ level,
+ dof_indices,
+ fe_index);
}
Assert (false, ExcNotImplemented ());
}
- internal::DoFAccessor::Implementation::set_mg_dof_indices (*this,
- level,
- dof_indices,
- fe_index);
+ internal::DoFAccessorImplementation::Implementation::set_mg_dof_indices (*this,
+ level,
+ dof_indices,
+ fe_index);
}
namespace internal
{
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
template <bool level_dof_access, typename DoFHandlerType>
inline
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<DoFHandlerType::dimension, DoFHandlerType::space_dimension> *,
unsigned int /*index*/,
DoFHandlerType *)
template <bool level_dof_access>
inline
- typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,2> *,
unsigned int,
dealii::DoFHandler<2,2> *)
{
Assert(false, ExcNotImplemented());
- return typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::line_iterator();
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::DoFHandler<2,2>, level_dof_access>::line_iterator();
}
template <bool level_dof_access>
inline
- typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,3> *,
unsigned int,
dealii::DoFHandler<2,3> *)
{
Assert(false, ExcNotImplemented());
- return typename dealii::internal::DoFHandler::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::line_iterator();
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::DoFHandler<2,3>, level_dof_access>::line_iterator();
}
template <bool level_dof_access>
inline
- typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,2> *,
unsigned int,
dealii::hp::DoFHandler<2,2> *)
{
Assert(false, ExcNotImplemented());
- return typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::line_iterator();
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::hp::DoFHandler<2,2>, level_dof_access>::line_iterator();
}
template <bool level_dof_access>
inline
- typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,3>, level_dof_access>::quad_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::hp::DoFHandler<2,3>, level_dof_access>::quad_iterator
get_quad(const dealii::Triangulation<2,3> *,
unsigned int,
dealii::hp::DoFHandler<2,3> *)
{
Assert(false, ExcNotImplemented());
- return typename dealii::internal::DoFHandler::Iterators<dealii::hp::DoFHandler<2,3>, level_dof_access>::line_iterator();
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<dealii::hp::DoFHandler<2,3>, level_dof_access>::line_iterator();
}
}
}
template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
-typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::line_iterator
+typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType,level_dof_access>::line_iterator
DoFAccessor<structdim,DoFHandlerType,level_dof_access>::line (const unsigned int i) const
{
// if we are asking for a particular line and this object refers to
Assert (i==0, ExcMessage ("You can only ask for line zero if the "
"current object is a line itself."));
return
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::cell_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType,level_dof_access>::cell_iterator
(&this->get_triangulation(),
this->level(),
this->index(),
Assert (DoFHandlerType::dimension > 1, ExcImpossibleInDim(DoFHandlerType::dimension));
// checking of 'i' happens in line_index(i)
- return typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::line_iterator
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType,level_dof_access>::line_iterator
(this->tria,
0, // only sub-objects are allowed, which have no level
this->line_index(i),
template <int structdim, typename DoFHandlerType, bool level_dof_access>
inline
-typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
+typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
DoFAccessor<structdim,DoFHandlerType,level_dof_access>::quad (const unsigned int i) const
{
// if we are asking for a
Assert (i==0, ExcMessage ("You can only ask for quad zero if the "
"current object is a quad itself."));
return
- typename dealii::internal::DoFHandler::Iterators<DoFHandlerType>::cell_iterator
+ typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType>::cell_iterator
(&this->get_triangulation(),
this->level(),
this->index(),
Assert (DoFHandlerType::dimension > 2, ExcImpossibleInDim(DoFHandlerType::dimension));
// checking of 'i' happens in quad_index(i)
- return typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
+ return typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
(this->tria,
0, // only sub-objects are allowed, which have no level
this->quad_index(i),
{
for (unsigned int i=0; i<dof_indices.size(); ++i)
dof_indices[i]
- = dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index (
+ = dealii::internal::DoFAccessorImplementation::Implementation::get_vertex_dof_index (
*dof_handler,
this->global_vertex_index,
fe_index,
{
(void)vertex;
Assert (vertex == 0, ExcIndexRange (vertex, 0, 1));
- return dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index (
+ return dealii::internal::DoFAccessorImplementation::Implementation::get_vertex_dof_index (
*dof_handler,
this->global_vertex_index,
fe_index,
dof_index (const unsigned int i,
const unsigned int fe_index) const
{
- return dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index
+ return dealii::internal::DoFAccessorImplementation::Implementation::get_vertex_dof_index
(*this->dof_handler,
this->vertex_index(0),
fe_index,
template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
inline
-typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator
+typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator
DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::line
(const unsigned int /*c*/) const
{
Assert(false, ExcNotImplemented());
return typename dealii::internal::
- DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator();
+ DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator();
}
template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
inline
-typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator
+typename dealii::internal::DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator
DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::quad
(const unsigned int /*c*/) const
{
Assert(false, ExcNotImplemented());
return typename dealii::internal::
- DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator();
+ DoFHandlerImplementation::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator();
}
namespace internal
{
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
// make sure we refer to class
// dealii::DoFCellAccessor, not
namespace internal
{
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
template <typename DoFHandlerType, bool level_dof_access>
inline
Assert (i<GeometryInfo<dim>::faces_per_cell, ExcIndexRange (i, 0, GeometryInfo<dim>::faces_per_cell));
const unsigned int dim = DoFHandlerType::dimension;
- return dealii::internal::DoFCellAccessor::get_face (*this, i, std::integral_constant<int, dim>());
+ return dealii::internal::DoFCellAccessorImplementation::get_face (*this, i, std::integral_constant<int, dim>());
}
const types::global_dof_index *cache
= this->dof_handler->levels[this->present_level]
->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
- dealii::internal::DoFAccessor::Implementation::extract_subvector_to(
+ dealii::internal::DoFAccessorImplementation::Implementation::extract_subvector_to(
values, cache, cache + this->get_fe().dofs_per_cell, local_values_begin);
}
"that are either locally owned or (after distributing "
"degrees of freedom) are ghost cells."));
- return dealii::internal::DoFCellAccessor::Implementation::active_fe_index (*this);
+ return dealii::internal::DoFCellAccessorImplementation::Implementation::active_fe_index (*this);
}
"will automatically be propagated from the owning process "
"of that cell, and there is no information at all on "
"artificial cells."));
- dealii::internal::DoFCellAccessor::Implementation::set_active_fe_index (*this, i);
+ dealii::internal::DoFCellAccessorImplementation::Implementation::set_active_fe_index (*this, i);
}
(const Vector<number> &local_source,
OutputVector &global_destination) const
{
- dealii::internal::DoFCellAccessor::Implementation::
+ dealii::internal::DoFCellAccessorImplementation::Implementation::
distribute_local_to_global (*this, local_source.begin(),
local_source.end(), global_destination);
}
ForwardIterator local_source_end,
OutputVector &global_destination) const
{
- dealii::internal::DoFCellAccessor::Implementation::
+ dealii::internal::DoFCellAccessorImplementation::Implementation::
distribute_local_to_global (*this, local_source_begin,
local_source_end, global_destination);
}
ForwardIterator local_source_end,
OutputVector &global_destination) const
{
- dealii::internal::DoFCellAccessor::Implementation::
+ dealii::internal::DoFCellAccessorImplementation::Implementation::
distribute_local_to_global (*this, constraints, local_source_begin,
local_source_end, global_destination);
}
(const FullMatrix<number> &local_source,
OutputMatrix &global_destination) const
{
- dealii::internal::DoFCellAccessor::Implementation::
+ dealii::internal::DoFCellAccessorImplementation::Implementation::
distribute_local_to_global (*this,local_source,global_destination);
}
OutputMatrix &global_matrix,
OutputVector &global_vector) const
{
- dealii::internal::DoFCellAccessor::Implementation::
+ dealii::internal::DoFCellAccessorImplementation::Implementation::
distribute_local_to_global (*this,local_matrix,local_vector,
global_matrix,global_vector);
}
*
* @ingroup dofs
*/
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
/**
/**
* The object containing the data of DoFs on lines.
*/
- internal::DoFHandler::DoFObjects<1> lines;
+ internal::DoFHandlerImplementation::DoFObjects<1> lines;
/**
* Determine an estimate for the memory consumption (in bytes) of this
/**
* The object containing the data of DoFs on lines.
*/
- internal::DoFHandler::DoFObjects<1> lines;
+ internal::DoFHandlerImplementation::DoFObjects<1> lines;
/**
* The object containing the data of DoFs on quads.
*/
- internal::DoFHandler::DoFObjects<2> quads;
+ internal::DoFHandlerImplementation::DoFObjects<2> quads;
/**
* Determine an estimate for the memory consumption (in bytes) of this
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
}
}
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
struct Implementation;
}
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
struct Implementation;
}
* matrices also refer to all degrees of freedom and some kind of condensation
* is needed to restrict the systems of equations to the unconstrained degrees
* of freedom only. The actual layout of storage of the indices is described
- * in the dealii::internal::DoFHandler::DoFLevel class documentation.
+ * in the dealii::internal::DoFHandlerImplementation::DoFLevel class documentation.
*
* The class offers iterators to traverse all cells, in much the same way as
* the Triangulation class does. Using the begin() and end() functions (and
template <int dim, int spacedim=dim>
class DoFHandler : public Subscriptor
{
- typedef dealii::internal::DoFHandler::Iterators<DoFHandler<dim,spacedim>, false> ActiveSelector;
- typedef dealii::internal::DoFHandler::Iterators<DoFHandler<dim,spacedim>, true> LevelSelector;
+ typedef dealii::internal::DoFHandlerImplementation::Iterators<DoFHandler<dim,spacedim>, false> ActiveSelector;
+ typedef dealii::internal::DoFHandlerImplementation::Iterators<DoFHandler<dim,spacedim>, true> LevelSelector;
public:
typedef typename ActiveSelector::CellAccessor cell_accessor;
typedef typename ActiveSelector::FaceAccessor face_accessor;
* An object that describes how degrees of freedom should be distributed and
* renumbered.
*/
- std::unique_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
+ std::unique_ptr<dealii::internal::DoFHandlerImplementation::Policy::PolicyBase<dim,spacedim> > policy;
/**
* A structure that contains all sorts of numbers that characterize the
* For most members of this structure, there is an accessor function in this
* class that returns its value.
*/
- dealii::internal::DoFHandler::NumberCache number_cache;
+ dealii::internal::DoFHandlerImplementation::NumberCache number_cache;
/**
* Data structure like number_cache, but for each multigrid level.
*/
- std::vector<dealii::internal::DoFHandler::NumberCache> mg_number_cache;
+ std::vector<dealii::internal::DoFHandlerImplementation::NumberCache> mg_number_cache;
/**
* A data structure that is used to store the DoF indices associated with a
* Space to store the DoF numbers for the different levels. Analogous to the
* <tt>levels[]</tt> tree of the Triangulation objects.
*/
- std::vector<std::unique_ptr<dealii::internal::DoFHandler::DoFLevel<dim> > > levels;
+ std::vector<std::unique_ptr<dealii::internal::DoFHandlerImplementation::DoFLevel<dim> > > levels;
- std::vector<std::unique_ptr<dealii::internal::DoFHandler::DoFLevel<dim> > > mg_levels;
+ std::vector<std::unique_ptr<dealii::internal::DoFHandlerImplementation::DoFLevel<dim> > > mg_levels;
/**
* Space to store DoF numbers of faces. They are not stored in
* <tt>levels</tt> since faces are not organized hierarchically, but in a
* flat array.
*/
- std::unique_ptr<dealii::internal::DoFHandler::DoFFaces<dim> > faces;
+ std::unique_ptr<dealii::internal::DoFHandlerImplementation::DoFFaces<dim> > faces;
- std::unique_ptr<dealii::internal::DoFHandler::DoFFaces<dim> > mg_faces;
+ std::unique_ptr<dealii::internal::DoFHandlerImplementation::DoFFaces<dim> > mg_faces;
/**
* Make accessor objects friends.
*/
template <int, class, bool> friend class DoFAccessor;
template <class, bool> friend class DoFCellAccessor;
- friend struct dealii::internal::DoFAccessor::Implementation;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
+ friend struct dealii::internal::DoFAccessorImplementation::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
- friend struct dealii::internal::DoFHandler::Implementation;
- friend struct dealii::internal::DoFHandler::Policy::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Policy::Implementation;
// explicitly check for sensible template arguments, but not on windows
// because MSVC creates bogus warnings during normal compilation
* Defined in dof_handler.cc.
*/
template <int dim, int spacedim>
- std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy);
+ std::string policy_to_string(const dealii::internal::DoFHandlerImplementation::Policy::PolicyBase<dim,spacedim> &policy);
}
levels.resize(size);
for (unsigned int i = 0; i < levels.size(); ++i)
{
- std::unique_ptr<internal::DoFHandler::DoFLevel<dim>> level;
+ std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<dim>> level;
ar &level;
levels[i] = std::move(level);
}
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct NumberCache;
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
template <typename DoFHandlerType, bool lda=false>
struct Iterators;
* Define some types for DoF handling in one dimension.
*
* The types have the same meaning as those declared in
- * internal::Triangulation::Iterators<1,spacedim>, only the treatment of
+ * internal::TriangulationImplementation::Iterators<1,spacedim>, only the treatment of
* templates is a little more complicated. See the
* @ref Iterators
* module for more information.
* Define some types for DoF handling in two dimensions.
*
* The types have the same meaning as those declared in
- * internal::Triangulation::Iterators<2,spacedim>, only the treatment of
+ * internal::TriangulationImplementation::Iterators<2,spacedim>, only the treatment of
* templates is a little more complicated. See the
* @ref Iterators
* module for more information.
* Define some types for DoF handling in three dimensions.
*
* The types have the same meaning as those declared in
- * internal::Triangulation::Iterators<3,spacedim>, only the treatment of
+ * internal::TriangulationImplementation::Iterators<3,spacedim>, only the treatment of
* templates is a little more complicated. See the
* @ref Iterators
* module for more information.
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
template <int> class DoFLevel;
template <int> class DoFFaces;
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
/**
* A structure used by the DoFHandler classes to store information about
* FEValues object for a given mapping and finite element object. The
* returned object will later be passed to FiniteElement::fill_fe_values()
* for a concrete cell, which will itself place its output into an object of
- * type internal::FEValues::FiniteElementRelatedData. Since there may be
+ * type internal::FEValuesImplementation::FiniteElementRelatedData. Since there may be
* data that can already be computed in its <i>final</i> form on the
* reference cell, this function also receives a reference to the
- * internal::FEValues::FiniteElementRelatedData object as its last argument.
+ * internal::FEValuesImplementation::FiniteElementRelatedData object as its last argument.
* This output argument is guaranteed to always be the same one when used
* with the InternalDataBase object returned by this function. In other
* words, the subdivision of scratch data and final data in the returned
get_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
/**
* Like get_data(), but return an object that will later be used for
get_face_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Like get_data(), but return an object that will later be used for
get_subface_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Compute information about the shape functions on the cell denoted by the
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
/**
* This function is the equivalent to FiniteElement::fill_fe_values(), but
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
/**
* This function is the equivalent to FiniteElement::fill_fe_values(), but
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const = 0;
friend class InternalDataBase;
friend class FEValuesBase<dim,spacedim>;
get_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
private:
* <code>base_no</code>th base element will write its output when calling
* FiniteElement::fill_fe_values() and similar functions.
*/
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
get_fe_output_object (const unsigned int base_no) const;
/**
get_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data) const;
virtual typename FiniteElement<dim,spacedim>::InternalDataBase *
get_face_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data) const;
virtual typename FiniteElement<dim,spacedim>::InternalDataBase *
get_subface_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void fill_fe_values (const typename Triangulation<dim, spacedim>::cell_iterator &cell,
const Quadrature<dim> &quadrature,
const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data
) const;
virtual
const Quadrature<dim-1> &quadrature,
const Mapping<dim, spacedim> &mapping,
const typename Mapping<dim, spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data
) const;
virtual
const Quadrature<dim-1> &quadrature,
const Mapping<dim, spacedim> &mapping,
const typename Mapping< dim, spacedim >::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data
) const;
private:
void
multiply_by_enrichment (const Quadrature<dim_1> &quadrature,
const InternalData &fe_data,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
const typename Triangulation< dim, spacedim >::cell_iterator &cell,
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data) const;
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data) const;
};
//}
get_data (const UpdateFlags /*update_flags*/,
const Mapping<1,spacedim> &/*mapping*/,
const Quadrature<1> &/*quadrature*/,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &/*output_data*/) const
{
return new typename FiniteElement<1, spacedim>::InternalDataBase;
}
get_face_data(const UpdateFlags update_flags,
const Mapping<1,spacedim> &/*mapping*/,
const Quadrature<0> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &/*output_data*/) const
{
// generate a new data object and initialize some fields
typename FiniteElement<1,spacedim>::InternalDataBase *data =
get_subface_data(const UpdateFlags update_flags,
const Mapping<1,spacedim> &mapping,
const Quadrature<0> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &output_data) const
{
return get_face_data(update_flags, mapping, quadrature, output_data);
}
const Quadrature<1> &quadrature,
const Mapping<1,spacedim> &mapping,
const typename Mapping<1,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &mapping_data,
const typename FiniteElement<1,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &output_data) const;
virtual
void
const Quadrature<0> &quadrature,
const Mapping<1,spacedim> &mapping,
const typename Mapping<1,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &mapping_data,
const typename FiniteElement<1,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &output_data) const;
virtual
void
const Quadrature<0> &quadrature,
const Mapping<1,spacedim> &mapping,
const typename Mapping<1,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &mapping_data,
const typename FiniteElement<1,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &output_data) const;
private:
/**
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Prepare internal data structures and fill in values independent of the
get_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Return whether this element dominates the one given as argument when they
get_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<2> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
virtual FiniteElement<2,2>::InternalDataBase *
get_face_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
virtual FiniteElement<2,2>::InternalDataBase *
get_subface_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
/**
* Compute the data on the current cell.
const Quadrature<2> &quadrature,
const Mapping<2,2> &mapping,
const Mapping<2,2>::InternalDataBase &mapping_internal,
- const internal::FEValues::MappingRelatedData<2,2> &mapping_data,
+ const internal::FEValuesImplementation::MappingRelatedData<2,2> &mapping_data,
const FiniteElement<2,2>::InternalDataBase &fe_internal,
- internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
/**
* Compute the data on the face of the current cell.
const Quadrature<1> &quadrature,
const Mapping<2,2> &mapping,
const Mapping<2,2>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<2,2> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,2> &mapping_data,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
/**
* Compute the data on the subface of the current cell.
const Quadrature<1> &quadrature,
const Mapping<2,2> &mapping,
const Mapping<2,2>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<2,2> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,2> &mapping_data,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const;
/**
* Create the constraints matrix for hanging edges.
get_data(const UpdateFlags update_flags,
const Mapping<dim,spacedim> &/*mapping*/,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// generate a new data object and
// initialize some fields
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Fields of cell-independent data.
* is the Jacobian pushed-forward second derivative.
*/
void
- correct_third_derivatives (internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
+ correct_third_derivatives (internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data,
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
const unsigned int n_q_points,
const unsigned int dof) const;
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
template <class PolynomialType, int dim, int spacedim>
inline void
FE_Poly<PolynomialType,dim,spacedim>::
-correct_third_derivatives (internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
+correct_third_derivatives (internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data,
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
const unsigned int n_q_points,
const unsigned int dof) const
{
get_data (const UpdateFlags /*update_flags*/,
const Mapping<dim,spacedim> &/*mapping*/,
const Quadrature<dim> &/*quadrature*/,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
InternalData *data = new InternalData;
return data;
get_face_data(const UpdateFlags update_flags,
const Mapping<dim,spacedim> &/*mapping*/,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// generate a new data object and
// initialize some fields
get_subface_data(const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
return get_face_data(update_flags, mapping,
QProjector<dim - 1>::project_to_all_children(quadrature),
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Fields of cell-independent data.
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &) const
{
// Do nothing, since we do not have
// values in the interior
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
get_data(const UpdateFlags update_flags,
const Mapping<dim,spacedim> &/*mapping*/,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// generate a new data object and
// initialize some fields
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Fields of cell-independent data for FE_PolyTensor. Stores the values of
get_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
typename FiniteElement<dim,spacedim>::InternalDataBase *
get_face_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
typename FiniteElement<dim,spacedim>::InternalDataBase *
get_subface_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
virtual
void
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const;
/**
* Do the work for the three <tt>fill_fe*_values</tt> functions.
const CellSimilarity::Similarity cell_similarity,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_data,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data) const;
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data) const;
private:
* <code>base_no</code>th base element will write its output when calling
* FiniteElement::fill_fe_values() and similar functions.
*/
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
get_fe_output_object (const unsigned int base_no) const;
private:
* The size of this vector is set to @p n_base_elements by the
* InternalData constructor.
*/
- mutable std::vector<internal::FEValues::FiniteElementRelatedData<dim,spacedim> > base_fe_output_objects;
+ mutable std::vector<internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> > base_fe_output_objects;
};
/*
namespace internal
{
- namespace FEValues
+ namespace FEValuesImplementation
{
/**
* A class that stores all of the mapping related data used in
* An object into which the Mapping::fill_fe_values() and similar functions
* place their output.
*/
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> mapping_output;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> mapping_output;
/**
* An object into which the FiniteElement::fill_fe_values() and similar
* functions place their output.
*/
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> finite_element_output;
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> finite_element_output;
/**
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const = 0;
/**
* This function is the equivalent to Mapping::fill_fe_values(), but for
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const = 0;
/**
* This function is the equivalent to Mapping::fill_fe_values(), but for
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const = 0;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const = 0;
/**
* @}
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_face_values()
virtual
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_subface_values()
virtual
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
/**
* @}
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_face_values()
virtual
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_subface_values()
virtual
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
/**
* @}
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_face_values()
virtual
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_subface_values()
virtual
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
/**
* @}
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_face_values()
virtual
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_subface_values()
virtual
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
/**
* @}
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
/**
* Compute the support points of the mapping. For the current class, these
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const override;
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const override;
/**
* Reference to the vector of shifts.
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_face_values()
virtual
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
// documentation can be found in Mapping::fill_fe_subface_values()
virtual
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &output_data) const override;
+ dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &output_data) const override;
/**
* @}
namespace internal
{
- namespace FilteredIterator
+ namespace FilteredIteratorImplementation
{
// The following classes create a nested sequence of
// FilteredIterator<FilteredIterator<...<BaseIterator>...>> with as many
* @ingroup CPP11
*/
template <typename BaseIterator, typename Predicate, typename... Targs>
-IteratorRange<typename internal::FilteredIterator::
+IteratorRange<typename internal::FilteredIteratorImplementation::
NestFilteredIterators<BaseIterator,std::tuple<Predicate, Targs...> >::type>
filter_iterators (IteratorRange<BaseIterator> i,
const Predicate &p,
namespace internal
{
- namespace TensorProductManifold
+ namespace TensorProductManifoldImplementation
{
template <int dim1, int dim2>
Tensor<1,dim1+dim2> concat(const Tensor<1,dim1> &p1, const Tensor<1,dim2> &p2)
const ChartManifold<dim_A, spacedim_A, chartdim_A> &manifold_A,
const ChartManifold<dim_B, spacedim_B, chartdim_B> &manifold_B)
: ChartManifold<dim,spacedim_A+spacedim_B,chartdim_A+chartdim_B> (
- internal::TensorProductManifold::concat(
+ internal::TensorProductManifoldImplementation::concat(
manifold_A.get_periodicity(),
manifold_B.get_periodicity())),
manifold_A (&manifold_A),
{
Point<spacedim_A> space_point_A;
Point<spacedim_B> space_point_B;
- internal::TensorProductManifold::split_point(space_point, space_point_A, space_point_B);
+ internal::TensorProductManifoldImplementation::split_point(space_point, space_point_A, space_point_B);
Point<chartdim_A> result_A = manifold_A->pull_back(space_point_A);
Point<chartdim_B> result_B = manifold_B->pull_back(space_point_B);
- return internal::TensorProductManifold::concat(result_A, result_B);
+ return internal::TensorProductManifoldImplementation::concat(result_A, result_B);
}
template <int dim,
{
Point<chartdim_A> chart_point_A;
Point<chartdim_B> chart_point_B;
- internal::TensorProductManifold::split_point(chart_point, chart_point_A, chart_point_B);
+ internal::TensorProductManifoldImplementation::split_point(chart_point, chart_point_A, chart_point_B);
Point<spacedim_A> result_A = manifold_A->push_forward(chart_point_A);
Point<spacedim_B> result_B = manifold_B->push_forward(chart_point_B);
- return internal::TensorProductManifold::concat(result_A, result_B);
+ return internal::TensorProductManifoldImplementation::concat(result_A, result_B);
}
template <int dim,
{
Point<chartdim_A> chart_point_A;
Point<chartdim_B> chart_point_B;
- internal::TensorProductManifold::split_point(chart_point, chart_point_A, chart_point_B);
+ internal::TensorProductManifoldImplementation::split_point(chart_point, chart_point_A, chart_point_B);
DerivativeForm<1,chartdim_A,spacedim_A> result_A
= manifold_A->push_forward_gradient(chart_point_A);
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <int dim> class TriaLevel;
template <int dim> class TriaFaces;
struct Implementation;
}
- namespace TriaAccessor
+ namespace TriaAccessorImplementation
{
struct Implementation;
}
* A namespace for classes internal to the triangulation classes and
* helpers.
*/
- namespace Triangulation
+ namespace TriangulationImplementation
{
/**
*
* This class is written to be as independent of the dimension as possible
* (thus the complex construction of the
- * dealii::internal::Triangulation::TriaLevel classes) to allow code-sharing,
+ * dealii::internal::TriangulationImplementation::TriaLevel classes) to allow code-sharing,
* to allow reducing the need to mirror changes in the code for one dimension
* to the code for other dimensions. Nonetheless, some of the functions are
* dependent of the dimension and there only exist specialized versions for
* An internal typedef to make the definition of the iterator classes
* simpler.
*/
- typedef dealii::internal::Triangulation::Iterators<dim, spacedim> IteratorSelector;
+ typedef dealii::internal::TriangulationImplementation::Iterators<dim, spacedim> IteratorSelector;
public:
/**
* Array of pointers pointing to the objects storing the cell data on the
* different levels.
*/
- std::vector<std::unique_ptr<dealii::internal::Triangulation::TriaLevel<dim> > > levels;
+ std::vector<std::unique_ptr<dealii::internal::TriangulationImplementation::TriaLevel<dim> > > levels;
/**
* Pointer to the faces of the triangulation. In 1d this contains nothing,
* in 2D it contains data concerning lines and in 3D quads and lines. All
* of these have no level and are therefore treated separately.
*/
- std::unique_ptr<dealii::internal::Triangulation::TriaFaces<dim> > faces;
+ std::unique_ptr<dealii::internal::TriangulationImplementation::TriaFaces<dim> > faces;
/**
* and since access to the number of lines etc is a rather frequent
* operation, this was not an optimal solution.
*/
- dealii::internal::Triangulation::NumberCache<dim> number_cache;
+ dealii::internal::TriangulationImplementation::NumberCache<dim> number_cache;
/**
* A map that relates the number of a boundary vertex to the boundary
friend class CellAccessor<dim, spacedim>;
- friend struct dealii::internal::TriaAccessor::Implementation;
+ friend struct dealii::internal::TriaAccessorImplementation::Implementation;
friend class hp::DoFHandler<dim,spacedim>;
- friend struct dealii::internal::Triangulation::Implementation;
+ friend struct dealii::internal::TriangulationImplementation::Implementation;
template <typename>
- friend class dealii::internal::Triangulation::TriaObjects;
+ friend class dealii::internal::TriangulationImplementation::TriaObjects;
// explicitly check for sensible template arguments, but not on windows
// because MSVC creates bogus warnings during normal compilation
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <class Archive>
void NumberCache<1>::serialize (Archive &ar,
levels.resize(size);
for (unsigned int i = 0; i < levels.size(); ++i)
{
- std::unique_ptr<internal::Triangulation::TriaLevel<dim>> level;
+ std::unique_ptr<internal::TriangulationImplementation::TriaLevel<dim>> level;
ar &level;
levels[i] = std::move(level);
}
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <int dim> class TriaObject;
template <typename G> class TriaObjects;
struct Implementation;
}
- namespace TriaAccessor
+ namespace TriaAccessorImplementation
{
struct Implementation;
/**
* Access to the other objects of a Triangulation with same dimension.
*/
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<structdim> > &
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<structdim> > &
objects () const;
public:
* The level if this is a cell (<tt>structdim==dim</tt>). Else, contains
* zero.
*/
- typename dealii::internal::TriaAccessor::PresentLevelType<structdim,dim>::type present_level;
+ typename dealii::internal::TriaAccessorImplementation::PresentLevelType<structdim,dim>::type present_level;
/**
* Used to store the index of the element presently pointed to on the level
/**
* Dummy function to extract lines. Returns a default-constructed line iterator.
*/
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
line (const unsigned int i) const;
/**
* Dummy function to extract quads. Returns a default-constructed quad iterator.
*/
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
quad (const unsigned int i) const;
};
/**
* Pointer to the @p ith line bounding this object.
*/
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
line (const unsigned int i) const;
/**
/**
* Pointer to the @p ith quad bounding this object.
*/
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
quad (const unsigned int i) const;
/**
* Copy the data of the given object into the internal data structures of a
* triangulation.
*/
- void set (const dealii::internal::Triangulation::TriaObject<structdim> &o) const;
+ void set (const dealii::internal::TriangulationImplementation::TriaObject<structdim> &o) const;
/**
* Set the flag indicating, what <code>line_orientation()</code> will
template <int, int> friend class Triangulation;
- friend struct dealii::internal::Triangulation::Implementation;
- friend struct dealii::internal::TriaAccessor::Implementation;
+ friend struct dealii::internal::TriangulationImplementation::Implementation;
+ friend struct dealii::internal::TriaAccessorImplementation::Implementation;
};
* Pointer to the @p ith line bounding this object. Will point to an invalid
* object.
*/
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
static line (const unsigned int);
/**
* Pointer to the @p ith quad bounding this object.
*/
static
- typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
quad (const unsigned int i);
/**
* Pointer to the @p ith line bounding this object. Will point to an invalid
* object.
*/
- typename dealii::internal::Triangulation::Iterators<1,spacedim>::line_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::line_iterator
static line (const unsigned int);
/**
* Pointer to the @p ith quad bounding this object.
*/
static
- typename dealii::internal::Triangulation::Iterators<1,spacedim>::quad_iterator
+ typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::quad_iterator
quad (const unsigned int i);
/**
template <int, int> friend class Triangulation;
- friend struct dealii::internal::Triangulation::Implementation;
+ friend struct dealii::internal::TriangulationImplementation::Implementation;
};
namespace internal
{
- namespace TriaAccessorBase
+ namespace TriaAccessorBaseImplementation
{
/**
* Out of a face object, get the sub-objects of dimensionality given by
*/
template <int dim>
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<1> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<dim> *faces,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<1> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<dim> *faces,
const std::integral_constant<int, 1>)
{
return &faces->lines;
template <int dim>
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<2> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<dim> *faces,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<2> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<dim> *faces,
const std::integral_constant<int, 2>)
{
return &faces->quads;
}
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<1> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<1> *,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<1> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<1> *,
const std::integral_constant<int, 1>)
{
Assert (false, ExcInternalError());
}
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<2> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<2> *,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<2> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<2> *,
const std::integral_constant<int, 2>)
{
Assert (false, ExcInternalError());
}
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<3> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<3> *,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<3> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<3> *,
const std::integral_constant<int, 3>)
{
Assert (false, ExcInternalError());
*/
template <int dim>
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<3> > *
- get_objects (dealii::internal::Triangulation::TriaFaces<dim> *,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<3> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaFaces<dim> *,
const std::integral_constant<int, 3>)
{
Assert (false, ExcInternalError());
*/
template <int structdim, int dim>
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<structdim> > *
- get_objects (dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<dim> > *,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<structdim> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<dim> > *,
const std::integral_constant<int, structdim>)
{
Assert (false, ExcInternalError());
template <int dim>
inline
- dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<dim> > *
- get_objects (dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<dim> > *cells,
+ dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<dim> > *
+ get_objects (dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<dim> > *cells,
const std::integral_constant<int, dim>)
{
return cells;
template <int structdim, int dim, int spacedim>
inline
-dealii::internal::Triangulation::TriaObjects<dealii::internal::Triangulation::TriaObject<structdim> > &
+dealii::internal::TriangulationImplementation::TriaObjects<dealii::internal::TriangulationImplementation::TriaObject<structdim> > &
TriaAccessorBase<structdim,dim,spacedim>::objects() const
{
if (structdim != dim)
// get sub-objects. note that the
// current class is only used for
// objects that are *not* cells
- return *dealii::internal::TriaAccessorBase::get_objects (this->tria->faces.get(),
- std::integral_constant<int, structdim> ());
+ return *dealii::internal::TriaAccessorBaseImplementation::get_objects (this->tria->faces.get(),
+ std::integral_constant<int, structdim> ());
else
- return *dealii::internal::TriaAccessorBase::get_objects (&this->tria->levels[this->present_level]->cells,
- std::integral_constant<int, structdim> ());
+ return *dealii::internal::TriaAccessorBaseImplementation::get_objects (&this->tria->levels[this->present_level]->cells,
+ std::integral_constant<int, structdim> ());
}
template <int structdim, int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
InvalidAccessor<structdim, dim, spacedim>::line (const unsigned int) const
{
// nothing to do here. we could throw an exception but we can't get here
// without first creating an object which would have already thrown
- return typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator();
+ return typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator();
}
template <int structdim, int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
InvalidAccessor<structdim, dim, spacedim>::quad (const unsigned int) const
{
// nothing to do here. we could throw an exception but we can't get here
// without first creating an object which would have already thrown
- return dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator();
+ return dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator();
}
namespace internal
{
- namespace TriaAccessor
+ namespace TriaAccessorImplementation
{
// make sure that if in the following we
// write TriaAccessor
Assert (corner<GeometryInfo<structdim>::vertices_per_cell,
ExcIndexRange(corner,0,GeometryInfo<structdim>::vertices_per_cell));
- return dealii::internal::TriaAccessor::Implementation::vertex_index (*this, corner);
+ return dealii::internal::TriaAccessorImplementation::Implementation::vertex_index (*this, corner);
}
template <int structdim, int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
TriaAccessor<structdim,dim,spacedim>::line (const unsigned int i) const
{
// checks happen in line_index
- return typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+ return typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
(this->tria, 0, line_index (i));
}
Assert (i < GeometryInfo<structdim>::lines_per_cell,
ExcIndexRange (i, 0, GeometryInfo<structdim>::lines_per_cell));
- return dealii::internal::TriaAccessor::Implementation::line_index (*this, i);
+ return dealii::internal::TriaAccessorImplementation::Implementation::line_index (*this, i);
}
template <int structdim, int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
TriaAccessor<structdim,dim,spacedim>::quad (const unsigned int i) const
{
// checks happen in quad_index
- return typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+ return typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
(this->tria, 0, quad_index (i));
}
unsigned int
TriaAccessor<structdim,dim,spacedim>::quad_index (const unsigned int i) const
{
- return dealii::internal::TriaAccessor::Implementation::quad_index (*this, i);
+ return dealii::internal::TriaAccessorImplementation::Implementation::quad_index (*this, i);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- return dealii::internal::TriaAccessor::Implementation::face_orientation (*this, face);
+ return dealii::internal::TriaAccessorImplementation::Implementation::face_orientation (*this, face);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- return dealii::internal::TriaAccessor::Implementation::face_flip (*this, face);
+ return dealii::internal::TriaAccessorImplementation::Implementation::face_flip (*this, face);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- return dealii::internal::TriaAccessor::Implementation::face_rotation (*this, face);
+ return dealii::internal::TriaAccessorImplementation::Implementation::face_rotation (*this, face);
}
Assert (line<GeometryInfo<structdim>::lines_per_cell,
ExcIndexRange (line, 0, GeometryInfo<structdim>::lines_per_cell));
- return dealii::internal::TriaAccessor::Implementation::line_orientation (*this, line);
+ return dealii::internal::TriaAccessorImplementation::Implementation::line_orientation (*this, line);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- dealii::internal::TriaAccessor::Implementation::set_face_orientation (*this, face, value);
+ dealii::internal::TriaAccessorImplementation::Implementation::set_face_orientation (*this, face, value);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- dealii::internal::TriaAccessor::Implementation::set_face_flip (*this, face, value);
+ dealii::internal::TriaAccessorImplementation::Implementation::set_face_flip (*this, face, value);
}
{
Assert (used(), TriaAccessorExceptions::ExcCellNotUsed());
- dealii::internal::TriaAccessor::Implementation::set_face_rotation (*this, face, value);
+ dealii::internal::TriaAccessorImplementation::Implementation::set_face_rotation (*this, face, value);
}
Assert (line<GeometryInfo<structdim>::lines_per_cell,
ExcIndexRange (line, 0, GeometryInfo<structdim>::lines_per_cell));
- dealii::internal::TriaAccessor::Implementation::set_line_orientation (*this, line, value);
+ dealii::internal::TriaAccessorImplementation::Implementation::set_line_orientation (*this, line, value);
}
template <int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator
TriaAccessor<0, dim, spacedim>::line (const unsigned int)
{
- return typename dealii::internal::Triangulation::Iterators<dim,spacedim>::line_iterator();
+ return typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::line_iterator();
}
template <int dim, int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator
TriaAccessor<0, dim, spacedim>::quad (const unsigned int)
{
- return typename dealii::internal::Triangulation::Iterators<dim,spacedim>::quad_iterator();
+ return typename dealii::internal::TriangulationImplementation::Iterators<dim,spacedim>::quad_iterator();
}
template <int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<1,spacedim>::line_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::line_iterator
TriaAccessor<0, 1, spacedim>::line (const unsigned int)
{
- return typename dealii::internal::Triangulation::Iterators<1,spacedim>::line_iterator();
+ return typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::line_iterator();
}
template <int spacedim>
inline
-typename dealii::internal::Triangulation::Iterators<1,spacedim>::quad_iterator
+typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::quad_iterator
TriaAccessor<0, 1, spacedim>::quad (const unsigned int)
{
- return typename dealii::internal::Triangulation::Iterators<1,spacedim>::quad_iterator();
+ return typename dealii::internal::TriangulationImplementation::Iterators<1,spacedim>::quad_iterator();
}
namespace internal
{
- namespace CellAccessor
+ namespace CellAccessorImplementation
{
template <int spacedim>
inline
TriaIterator<TriaAccessor<dim-1, dim, spacedim> >
CellAccessor<dim,spacedim>::face (const unsigned int i) const
{
- return dealii::internal::CellAccessor::get_face (*this, i);
+ return dealii::internal::CellAccessorImplementation::get_face (*this, i);
}
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
/**
* General template for information belonging to the faces of a
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <int dim, int spacedim>
struct Iterators;
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
/**
* Store all information which belongs to one level of the multilevel
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
/**
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
/**
* the DoF indices on cells.
*
* The things we store here is very similar to what is stored in the
- * internal::DoFHandler::DoFObjects classes (see there for more
+ * internal::DoFHandlerImplementation::DoFObjects classes (see there for more
* information, in particular on the layout of the class hierarchy, and
* the use of file names).
*
* For hp methods, not all cells may use the same finite element, and it
* is consequently more complicated to determine where the DoF indices for
* a given line, quad, or hex are stored. As described in the
- * documentation of the internal::DoFHandler::DoFLevel class, we can
+ * documentation of the internal::DoFHandlerImplementation::DoFLevel class, we can
* compute the location of the first line DoF, for example, by calculating
* the offset as <code>line_index *
* dof_handler.get_fe().dofs_per_line</code>. This of course doesn't work
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
{
class DoFLevel;
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
}
namespace internal
{
- namespace DoFAccessor
+ namespace DoFAccessorImplementation
{
struct Implementation;
}
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
struct Implementation;
}
template <int dim, int spacedim=dim>
class DoFHandler : public Subscriptor
{
- typedef dealii::internal::DoFHandler::Iterators<DoFHandler<dim,spacedim>, false> ActiveSelector;
- typedef dealii::internal::DoFHandler::Iterators<DoFHandler<dim,spacedim>, true> LevelSelector;
+ typedef dealii::internal::DoFHandlerImplementation::Iterators<DoFHandler<dim,spacedim>, false> ActiveSelector;
+ typedef dealii::internal::DoFHandlerImplementation::Iterators<DoFHandler<dim,spacedim>, true> LevelSelector;
public:
typedef typename ActiveSelector::CellAccessor cell_accessor;
typedef typename ActiveSelector::FaceAccessor face_accessor;
* An object that describes how degrees of freedom should be distributed and
* renumbered.
*/
- std::unique_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
+ std::unique_ptr<dealii::internal::DoFHandlerImplementation::Policy::PolicyBase<dim,spacedim> > policy;
/**
* For most members of this structure, there is an accessor function in
* this class that returns its value.
*/
- dealii::internal::DoFHandler::NumberCache number_cache;
+ dealii::internal::DoFHandlerImplementation::NumberCache number_cache;
/**
* A structure that contains all sorts of numbers that characterize the
* degrees of freedom on multigrid levels. Since multigrid is not currently
* supported, this table is not filled with valid entries.
*/
- std::vector<dealii::internal::DoFHandler::NumberCache> mg_number_cache;
+ std::vector<dealii::internal::DoFHandlerImplementation::NumberCache> mg_number_cache;
/**
* Array to store the indices for degrees of freedom located at vertices.
*/
template <int, class, bool> friend class dealii::DoFAccessor;
template <class, bool> friend class dealii::DoFCellAccessor;
- friend struct dealii::internal::DoFAccessor::Implementation;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
+ friend struct dealii::internal::DoFAccessorImplementation::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
/**
* Likewise for DoFLevel objects since they need to access the vertex dofs
* in the functions that set and retrieve vertex dof indices.
*/
template <int> friend class dealii::internal::hp::DoFIndicesOnFacesOrEdges;
- friend struct dealii::internal::hp::DoFHandler::Implementation;
- friend struct dealii::internal::DoFHandler::Policy::Implementation;
+ friend struct dealii::internal::hp::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::DoFHandlerImplementation::Policy::Implementation;
};
* Defined in source/dofs/dof_handler.cc.
*/
template <int dim, int spacedim>
- std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy);
+ std::string policy_to_string(const dealii::internal::DoFHandlerImplementation::Policy::PolicyBase<dim,spacedim> &policy);
}
{
namespace hp
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
struct Implementation;
}
}
- namespace DoFCellAccessor
+ namespace DoFCellAccessorImplementation
{
struct Implementation;
}
* class that needs to create these data structures.
*/
template <int, int> friend class dealii::hp::DoFHandler;
- friend struct dealii::internal::hp::DoFHandler::Implementation;
- friend struct dealii::internal::DoFCellAccessor::Implementation;
+ friend struct dealii::internal::hp::DoFHandlerImplementation::Implementation;
+ friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
};
namespace internal
{
- namespace BlockLinearOperator
+ namespace BlockLinearOperatorImplementation
{
- template <typename PayloadBlockType = internal::LinearOperator::EmptyPayload>
+ template <typename PayloadBlockType = internal::LinearOperatorImplementation::EmptyPayload>
class EmptyBlockPayload;
}
}
template <typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
class BlockLinearOperator;
template <typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<>,
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<>,
typename BlockMatrixType>
BlockLinearOperator<Range, Domain, BlockPayload>
block_operator(const BlockMatrixType &matrix);
template <size_t m, size_t n,
typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
BlockLinearOperator<Range, Domain, BlockPayload>
block_operator(const std::array<std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, typename BlockPayload::BlockType>, n>, m> &);
template <size_t m,
typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
BlockLinearOperator<Range, Domain, BlockPayload>
block_diagonal_operator(const std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, typename BlockPayload::BlockType>, m> &);
template <size_t m,
typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
BlockLinearOperator<Range, Domain, BlockPayload>
block_diagonal_operator(const LinearOperator<typename Range::BlockType, typename Domain::BlockType, typename BlockPayload::BlockType> &op);
template <typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<>,
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<>,
typename BlockMatrixType>
BlockLinearOperator<Range, Domain, BlockPayload>
block_diagonal_operator(const BlockMatrixType &block_matrix);
template <typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
LinearOperator<Domain, Range, typename BlockPayload::BlockType>
block_forward_substitution(const BlockLinearOperator<Range, Domain, BlockPayload> &,
const BlockLinearOperator<Domain, Range, BlockPayload> &);
template <typename Range = BlockVector<double>,
typename Domain = Range,
- typename BlockPayload = internal::BlockLinearOperator::EmptyBlockPayload<> >
+ typename BlockPayload = internal::BlockLinearOperatorImplementation::EmptyBlockPayload<> >
LinearOperator<Domain, Range, typename BlockPayload::BlockType>
block_back_substitution(const BlockLinearOperator<Range, Domain, BlockPayload> &,
const BlockLinearOperator<Domain, Range, BlockPayload> &);
namespace internal
{
- namespace BlockLinearOperator
+ namespace BlockLinearOperatorImplementation
{
// Populate the LinearOperator interfaces with the help of the
// BlockLinearOperator functions
return BlockType(block_matrix.block(i, j));
};
- internal::BlockLinearOperator::populate_linear_operator_functions(return_op);
+ internal::BlockLinearOperatorImplementation::populate_linear_operator_functions(return_op);
return return_op;
}
return ops[i][j];
};
- internal::BlockLinearOperator::populate_linear_operator_functions(return_op);
+ internal::BlockLinearOperatorImplementation::populate_linear_operator_functions(return_op);
return return_op;
}
return null_operator(BlockType(block_matrix.block(i, j)));
};
- internal::BlockLinearOperator::populate_linear_operator_functions(return_op);
+ internal::BlockLinearOperatorImplementation::populate_linear_operator_functions(return_op);
return return_op;
}
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
// the vectorization features of modern processors. to make this happen,
// we will have to vectorize the functions in the following namespace, either
// by hand or by using, for example, optimized BLAS versions for them.
- namespace ChunkSparseMatrix
+ namespace ChunkSparseMatrixImplementation
{
/**
* Declare type for container size.
namespace internal
{
- namespace ChunkSparseMatrix
+ namespace ChunkSparseMatrixImplementation
{
template <typename T>
void zero_subrange (const unsigned int begin,
const unsigned int matrix_size = cols->sparsity_pattern.n_nonzero_elements()
* cols->chunk_size * cols->chunk_size;
const unsigned int grain_size =
- internal::SparseMatrix::minimum_parallel_grain_size *
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size *
(matrix_size+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std::bind(&internal::ChunkSparseMatrix::template
+ std::bind(&internal::ChunkSparseMatrixImplementation::template
zero_subrange<number>,
std::placeholders::_1, std::placeholders::_2,
val.get()),
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, cols->sparsity_pattern.n_rows(),
- std::bind (&internal::ChunkSparseMatrix::vmult_add_on_subrange
+ std::bind (&internal::ChunkSparseMatrixImplementation::vmult_add_on_subrange
<number,InVector,OutVector>,
std::cref(*cols),
std::placeholders::_1, std::placeholders::_2,
cols->sparsity_pattern.colnums.get(),
std::cref(src),
std::ref(dst)),
- internal::SparseMatrix::minimum_parallel_grain_size/cols->chunk_size+1);
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size/cols->chunk_size+1);
}
if ((cols_have_padding == false)
||
(*colnum_ptr != cols->sparsity_pattern.n_cols()-1))
- internal::ChunkSparseMatrix::chunk_Tvmult_add
+ internal::ChunkSparseMatrixImplementation::chunk_Tvmult_add
(cols->chunk_size,
val_ptr,
src.begin() + chunk_row * cols->chunk_size,
||
(*colnum_ptr != cols->sparsity_pattern.n_cols()-1))
result +=
- internal::ChunkSparseMatrix::
+ internal::ChunkSparseMatrixImplementation::
chunk_matrix_scalar_product<somenumber>
(cols->chunk_size,
val_ptr,
||
(*colnum_ptr != cols->sparsity_pattern.n_cols()-1))
result +=
- internal::ChunkSparseMatrix::
+ internal::ChunkSparseMatrixImplementation::
chunk_matrix_scalar_product<somenumber>
(cols->chunk_size,
val_ptr,
if ((cols_have_padding == false)
||
(*colnum_ptr != cols->sparsity_pattern.n_cols()-1))
- internal::ChunkSparseMatrix::chunk_vmult_subtract
+ internal::ChunkSparseMatrixImplementation::chunk_vmult_subtract
(cols->chunk_size,
val_ptr,
u.begin() + *colnum_ptr * cols->chunk_size,
// number of functions to select the right implementation for set_zero().
namespace internal
{
- namespace ConstraintMatrix
+ namespace ConstraintMatrixImplementation
{
namespace
{
std::vector<size_type> constrained_lines(lines.size());
for (unsigned int i=0; i<lines.size(); ++i)
constrained_lines[i] = lines[i].index;
- internal::ConstraintMatrix::set_zero_all(constrained_lines, vec);
+ internal::ConstraintMatrixImplementation::set_zero_all(constrained_lines, vec);
}
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
class EmptyPayload;
}
template <typename Range = Vector<double>,
typename Domain = Range,
- typename Payload = internal::LinearOperator::EmptyPayload>
+ typename Payload = internal::LinearOperatorImplementation::EmptyPayload>
class LinearOperator;
template <typename Range = Vector<double>,
typename Domain = Range,
- typename Payload = internal::LinearOperator::EmptyPayload,
+ typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
typename OperatorExemplar,
typename Matrix>
LinearOperator<Range, Domain, Payload> linear_operator (const OperatorExemplar &,
template <typename Range = Vector<double>,
typename Domain = Range,
- typename Payload = internal::LinearOperator::EmptyPayload,
+ typename Payload = internal::LinearOperatorImplementation::EmptyPayload,
typename Matrix>
LinearOperator<Range, Domain, Payload> linear_operator (const Matrix &);
template <typename Range = Vector<double>,
typename Domain = Range,
- typename Payload = internal::LinearOperator::EmptyPayload>
+ typename Payload = internal::LinearOperatorImplementation::EmptyPayload>
LinearOperator<Range, Domain, Payload>
null_operator(const LinearOperator<Range, Domain, Payload> &);
* For example: LinearOperator instances representing matrix inverses usually
* require calling some linear solver. These solvers may not have interfaces
* to the LinearOperator (which, for example, may represent a composite
- * operation). The TrilinosWrappers::internal::LinearOperator::TrilinosPayload
+ * operation). The TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload
* therefore provides an interface extension to the LinearOperator so that it
* can be passed to the solver and used by the solver as if it were a Trilinos
* operator. This implies that all of the necessary functionality of the
* @ingroup LAOperators
*/
template <typename Range,
- typename Payload = internal::LinearOperator::EmptyPayload>
+ typename Payload = internal::LinearOperatorImplementation::EmptyPayload>
LinearOperator<Range, Range, Payload>
identity_operator(const std::function<void(Range &, bool)> &reinit_vector)
{
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
/**
* A helper class that is responsible for the initialization of a vector
return_op.reinit_range_vector = [&operator_exemplar](Range &v, bool omit_zeroing_entries)
{
- internal::LinearOperator::ReinitHelper<Range>::reinit_range_vector(operator_exemplar, v, omit_zeroing_entries);
+ internal::LinearOperatorImplementation::ReinitHelper<Range>::reinit_range_vector(operator_exemplar, v, omit_zeroing_entries);
};
return_op.reinit_domain_vector = [&operator_exemplar](Domain &v, bool omit_zeroing_entries)
{
- internal::LinearOperator::ReinitHelper<Domain>::reinit_domain_vector(operator_exemplar, v, omit_zeroing_entries);
+ internal::LinearOperatorImplementation::ReinitHelper<Domain>::reinit_domain_vector(operator_exemplar, v, omit_zeroing_entries);
};
typename std::conditional<
namespace internal
{
- namespace MatrixOut
+ namespace MatrixOutImplementation
{
namespace
{
if (options.block_size == 1)
{
if (options.show_absolute_values == true)
- return std::fabs(internal::MatrixOut::get_element (matrix, i, j));
+ return std::fabs(internal::MatrixOutImplementation::get_element (matrix, i, j));
else
- return internal::MatrixOut::get_element (matrix, i, j);
+ return internal::MatrixOutImplementation::get_element (matrix, i, j);
}
// if blocksize greater than one,
col < std::min(size_type(matrix.m()),
size_type((j+1)*options.block_size)); ++col, ++n_elements)
if (options.show_absolute_values == true)
- average += std::fabs(internal::MatrixOut::get_element (matrix, row, col));
+ average += std::fabs(internal::MatrixOutImplementation::get_element (matrix, row, col));
else
- average += internal::MatrixOut::get_element (matrix, row, col);
+ average += internal::MatrixOutImplementation::get_element (matrix, row, col);
average /= n_elements;
return average;
}
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
namespace internal
{
- namespace PreconditionChebyshev
+ namespace PreconditionChebyshevImplementation
{
// for deal.II vectors, perform updates for Chebyshev preconditioner all
// at once to reduce memory transfer. Here, we select between general
:
updater (updater)
{
- if (size < internal::Vector::minimum_parallel_grain_size)
+ if (size < internal::VectorImplementation::minimum_parallel_grain_size)
apply_to_subrange (0, size);
else
apply_parallel (0, size,
- internal::Vector::minimum_parallel_grain_size);
+ internal::VectorImplementation::minimum_parallel_grain_size);
}
~VectorUpdatesRange() = default;
{
matrix_ptr = &matrix;
data = additional_data;
- internal::PreconditionChebyshev::initialize_preconditioner(matrix,
- data.preconditioner,
- data.matrix_diagonal_inverse);
+ internal::PreconditionChebyshevImplementation::initialize_preconditioner(matrix,
+ data.preconditioner,
+ data.matrix_diagonal_inverse);
eigenvalues_are_initialized = false;
}
std::sqrt(std::numeric_limits<typename VectorType::value_type>::epsilon()),
1e-10, false, false);
- internal::PreconditionChebyshev::EigenvalueTracker eigenvalue_tracker;
+ internal::PreconditionChebyshevImplementation::EigenvalueTracker eigenvalue_tracker;
SolverCG<VectorType> solver (control);
- solver.connect_eigenvalues_slot(std::bind(&internal::PreconditionChebyshev::EigenvalueTracker::slot,
+ solver.connect_eigenvalues_slot(std::bind(&internal::PreconditionChebyshevImplementation::EigenvalueTracker::slot,
&eigenvalue_tracker,
std::placeholders::_1));
// set an initial guess which is close to the constant vector but where
// one entry is different to trigger high frequencies
- internal::PreconditionChebyshev::set_initial_guess(update2);
+ internal::PreconditionChebyshevImplementation::set_initial_guess(update2);
try
{
const double rhokp = 1./(2.*sigma-rhok);
const double factor1 = rhokp * rhok, factor2 = 2.*rhokp/delta;
rhok = rhokp;
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, false, factor1, factor2, update1, update2, update3, dst);
}
}
const double rhokp = 1./(2.*sigma-rhok);
const double factor1 = rhokp * rhok, factor2 = 2.*rhokp/delta;
rhok = rhokp;
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, false, factor1, factor2, update1, update2, update3, dst);
}
}
if (eigenvalues_are_initialized == false)
estimate_eigenvalues(src);
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, true, 0., 1./theta, update1, update2, update3, dst);
do_chebyshev_loop(dst, src);
if (eigenvalues_are_initialized == false)
estimate_eigenvalues(src);
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, true, 0., 1./theta, update1, update2, update3, dst);
do_transpose_chebyshev_loop(dst, src);
estimate_eigenvalues(src);
matrix_ptr->vmult (update2, dst);
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, false, 0., 1./theta, update1, update2, update3, dst);
do_chebyshev_loop(dst, src);
estimate_eigenvalues(src);
matrix_ptr->Tvmult (update2, dst);
- internal::PreconditionChebyshev::vector_updates
+ internal::PreconditionChebyshevImplementation::vector_updates
(src, *data.preconditioner, false, 0., 1./theta, update1, update2, update3, dst);
do_transpose_chebyshev_loop(dst, src);
free(val);
Utilities::System::posix_memalign ((void **)&val, 64, sizeof(Number)*new_alloc_size);
- if (new_alloc_size >= 4*dealii::internal::Vector::minimum_parallel_grain_size)
+ if (new_alloc_size >= 4*dealii::internal::VectorImplementation::minimum_parallel_grain_size)
thread_loop_partitioner = std::make_shared<parallel::internal::TBBPartitioner>();
}
}
/**
* A namespace for a helper class to the GMRES solver.
*/
- namespace SolverGMRES
+ namespace SolverGMRESImplementation
{
/**
* Class to hold temporary vectors. This class automatically allocates a
*/
boost::signals2::connection
connect_krylov_space_slot(
- const std::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot);
+ const std::function<void (const internal::SolverGMRESImplementation::TmpVectors<VectorType> &)> &slot);
/**
* Signal used to retrieve the Krylov space basis vectors. Called once
* when all iterations are ended.
*/
- boost::signals2::signal<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> krylov_space_signal;
+ boost::signals2::signal<void (const internal::SolverGMRESImplementation::TmpVectors<VectorType> &)> krylov_space_signal;
/**
* Signal used to retrieve a notification
*/
static double
modified_gram_schmidt
- (const internal::SolverGMRES::TmpVectors<VectorType> &orthogonal_vectors,
+ (const internal::SolverGMRESImplementation::TmpVectors<VectorType> &orthogonal_vectors,
const unsigned int dim,
const unsigned int accumulated_iterations,
VectorType &vv,
#ifndef DOXYGEN
namespace internal
{
- namespace SolverGMRES
+ namespace SolverGMRESImplementation
{
template <class VectorType>
inline
inline
double
SolverGMRES<VectorType>::modified_gram_schmidt
-(const internal::SolverGMRES::TmpVectors<VectorType> &orthogonal_vectors,
+(const internal::SolverGMRESImplementation::TmpVectors<VectorType> &orthogonal_vectors,
const unsigned int dim,
const unsigned int accumulated_iterations,
VectorType &vv,
eigenvalues[i] = mat_eig.eigenvalue(i);
//Sort eigenvalues for nicer output.
std::sort(eigenvalues.begin(), eigenvalues.end(),
- internal::SolverGMRES::complex_less_pred);
+ internal::SolverGMRESImplementation::complex_less_pred);
eigenvalues_signal(eigenvalues);
}
//Calculate condition number, avoid calculating the svd if a slot
const unsigned int n_tmp_vectors = additional_data.max_n_tmp_vectors;
// Generate an object where basis vectors are stored.
- internal::SolverGMRES::TmpVectors<VectorType> tmp_vectors (n_tmp_vectors, this->memory);
+ internal::SolverGMRESImplementation::TmpVectors<VectorType> tmp_vectors (n_tmp_vectors, this->memory);
// number of the present iteration; this
// number is not reset to zero upon a
template <class VectorType>
boost::signals2::connection
SolverGMRES<VectorType>::connect_krylov_space_slot
-(const std::function<void (const internal::SolverGMRES::TmpVectors<VectorType> &)> &slot)
+(const std::function<void (const internal::SolverGMRESImplementation::TmpVectors<VectorType> &)> &slot)
{
return krylov_space_signal.connect(slot);
}
const unsigned int basis_size = additional_data.max_basis_size;
// Generate an object where basis vectors are stored.
- typename internal::SolverGMRES::TmpVectors<VectorType> v (basis_size, this->memory);
- typename internal::SolverGMRES::TmpVectors<VectorType> z (basis_size, this->memory);
+ typename internal::SolverGMRESImplementation::TmpVectors<VectorType> v (basis_size, this->memory);
+ typename internal::SolverGMRESImplementation::TmpVectors<VectorType> z (basis_size, this->memory);
// number of the present iteration; this number is not reset to zero upon a
// restart
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
typedef types::global_dof_index size_type;
// per row on average.
const std::size_t matrix_size = cols->n_nonzero_elements();
const size_type grain_size =
- internal::SparseMatrix::minimum_parallel_grain_size *
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size *
(cols->n_nonzero_elements()+m()) / m();
if (matrix_size>grain_size)
parallel::apply_to_subranges (0U, matrix_size,
- std::bind(&internal::SparseMatrix::template
+ std::bind(&internal::SparseMatrixImplementation::template
zero_subrange<number>,
std::placeholders::_1, std::placeholders::_2,
val.get()),
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
/**
* Perform a vmult using the SparseMatrix data structures, but only using
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std::bind (&internal::SparseMatrix::vmult_on_subrange
+ std::bind (&internal::SparseMatrixImplementation::vmult_on_subrange
<number,InVector,OutVector>,
std::placeholders::_1, std::placeholders::_2,
val.get(),
std::cref(src),
std::ref(dst),
false),
- internal::SparseMatrix::minimum_parallel_grain_size);
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size);
}
Assert (!PointerComparison::equal(&src, &dst), ExcSourceEqualsDestination());
parallel::apply_to_subranges (0U, m(),
- std::bind (&internal::SparseMatrix::vmult_on_subrange
+ std::bind (&internal::SparseMatrixImplementation::vmult_on_subrange
<number,InVector,OutVector>,
std::placeholders::_1, std::placeholders::_2,
val.get(),
std::cref(src),
std::ref(dst),
true),
- internal::SparseMatrix::minimum_parallel_grain_size);
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size);
}
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
/**
* Perform a vmult using the SparseMatrix data structures, but only using
return
parallel::accumulate_from_subranges<somenumber>
- (std::bind (&internal::SparseMatrix::matrix_norm_sqr_on_subrange
+ (std::bind (&internal::SparseMatrixImplementation::matrix_norm_sqr_on_subrange
<number,Vector<somenumber> >,
std::placeholders::_1, std::placeholders::_2,
val.get(),
cols->colnums.get(),
std::cref(v)),
0, m(),
- internal::SparseMatrix::minimum_parallel_grain_size);
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size);
}
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
/**
* Perform a vmult using the SparseMatrix data structures, but only using
return
parallel::accumulate_from_subranges<somenumber>
- (std::bind (&internal::SparseMatrix::matrix_scalar_product_on_subrange
+ (std::bind (&internal::SparseMatrixImplementation::matrix_scalar_product_on_subrange
<number,Vector<somenumber> >,
std::placeholders::_1, std::placeholders::_2,
val.get(),
std::cref(u),
std::cref(v)),
0, m(),
- internal::SparseMatrix::minimum_parallel_grain_size);
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size);
}
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
/**
* Perform a vmult using the SparseMatrix data structures, but only using
return
std::sqrt (parallel::accumulate_from_subranges<somenumber>
- (std::bind (&internal::SparseMatrix::residual_sqr_on_subrange
+ (std::bind (&internal::SparseMatrixImplementation::residual_sqr_on_subrange
<number,Vector<somenumber>,Vector<somenumber> >,
std::placeholders::_1, std::placeholders::_2,
val.get(),
std::cref(b),
std::ref(dst)),
0, m(),
- internal::SparseMatrix::minimum_parallel_grain_size));
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size));
}
namespace internal
{
- namespace BlockLinearOperator
+ namespace BlockLinearOperatorImplementation
{
/**
template <typename... Args>
TrilinosBlockPayload (const Args &...)
{
- static_assert(typeid(PayloadBlockType)==typeid(internal::LinearOperator::TrilinosPayload),
+ static_assert(typeid(PayloadBlockType)==typeid(internal::LinearOperatorImplementation::TrilinosPayload),
"TrilinosBlockPayload can only accept a payload of type TrilinosPayload.");
}
};
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
class TrilinosPayload;
}
- namespace BlockLinearOperator
+ namespace BlockLinearOperatorImplementation
{
template <typename PayloadBlockType>
class TrilinosBlockPayload;
*/
template <typename Range, typename Domain = Range,
typename Matrix>
- inline LinearOperator<Range, Domain, TrilinosWrappers::internal::LinearOperator::TrilinosPayload>
+ inline LinearOperator<Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
linear_operator(const TrilinosWrappers::SparseMatrix &operator_exemplar, const Matrix &matrix)
{
typedef TrilinosWrappers::SparseMatrix OperatorExemplar;
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload Payload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload Payload;
return dealii::linear_operator<Range, Domain, Payload, OperatorExemplar, Matrix>(operator_exemplar, matrix);
}
* @ingroup TrilinosWrappers
*/
template <typename Range, typename Domain = Range>
- inline LinearOperator<Range, Domain, TrilinosWrappers::internal::LinearOperator::TrilinosPayload>
+ inline LinearOperator<Range, Domain, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
linear_operator(const TrilinosWrappers::SparseMatrix &matrix)
{
typedef TrilinosWrappers::SparseMatrix Matrix;
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload Payload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload Payload;
return dealii::linear_operator<Range, Domain, Payload, Matrix, Matrix>(matrix, matrix);
}
*/
template <typename Range,
typename Domain = Range>
- inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperator::TrilinosPayload> >
+ inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload> >
block_operator(const TrilinosWrappers::BlockSparseMatrix &block_matrix)
{
typedef TrilinosWrappers::BlockSparseMatrix BlockMatrix;
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadBlockType;
- typedef TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadBlockType;
+ typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
return dealii::block_operator<Range,Domain,BlockPayload,BlockMatrix>(block_matrix);
}
template <size_t m, size_t n,
typename Range,
typename Domain = Range>
- inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperator::TrilinosPayload> >
- block_operator(const std::array<std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperator::TrilinosPayload>, n>, m> &ops)
+ inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload> >
+ block_operator(const std::array<std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>, n>, m> &ops)
{
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadBlockType;
- typedef TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadBlockType;
+ typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
return dealii::block_operator<m,n,Range,Domain,BlockPayload>(ops);
}
*/
template <typename Range,
typename Domain = Range>
- inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperator::TrilinosPayload> >
+ inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload> >
block_diagonal_operator(const TrilinosWrappers::BlockSparseMatrix &block_matrix)
{
typedef TrilinosWrappers::BlockSparseMatrix BlockMatrix;
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadBlockType;
- typedef TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadBlockType;
+ typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
return dealii::block_diagonal_operator<Range, Domain, BlockPayload, BlockMatrix>(block_matrix);
}
* @ingroup TrilinosWrappers
*/
template <size_t m, typename Range, typename Domain = Range>
- inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperator::TrilinosPayload> >
- block_diagonal_operator(const std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperator::TrilinosPayload>, m> &ops)
+ inline BlockLinearOperator<Range, Domain, TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload> >
+ block_diagonal_operator(const std::array<LinearOperator<typename Range::BlockType, typename Domain::BlockType, TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>, m> &ops)
{
- typedef TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadBlockType;
- typedef TrilinosWrappers::internal::BlockLinearOperator::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
+ typedef TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadBlockType;
+ typedef TrilinosWrappers::internal::BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType> BlockPayload;
return dealii::block_diagonal_operator<m,Range,Domain,BlockPayload>(ops);
}
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
}
}
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
/**
* reference to the <tt>vmult</tt> and <tt>Tvmult</tt> functions. This
* object is not thread-safe when the transpose flag is set on it or the
* Trilinos object to which it refers. See the docuemtation for the
- * TrilinosWrappers::internal::LinearOperator::TrilinosPayload::SetUseTranspose()
+ * TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload::SetUseTranspose()
* function for further details.
*
* @author Jean-Paul Pelteret, 2016
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename Solver, typename Preconditioner>
typename std::enable_if<
namespace internal
{
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
template <typename> class ReinitHelper;
// only reset the partitioner if we actually expect a significant vector
// size
- if (vec_size >= 4*internal::Vector::minimum_parallel_grain_size)
+ if (vec_size >= 4*internal::VectorImplementation::minimum_parallel_grain_size)
thread_loop_partitioner = std::make_shared<parallel::internal::TBBPartitioner>();
}
// only reset the partitioner if we actually expect a significant vector
// size
- if (vec_size >= 4*internal::Vector::minimum_parallel_grain_size)
+ if (vec_size >= 4*internal::VectorImplementation::minimum_parallel_grain_size)
thread_loop_partitioner = std::make_shared<parallel::internal::TBBPartitioner>();
}
namespace internal
{
- namespace GrowingVectorMemory
+ namespace GrowingVectorMemoryImplementation
{
void release_all_unused_memory();
}
{
const size_type vec_size = end-start;
// set chunk size for sub-tasks
- const unsigned int gs = internal::Vector::minimum_parallel_grain_size;
+ const unsigned int gs = internal::VectorImplementation::minimum_parallel_grain_size;
n_chunks = std::min(static_cast<size_type>(4*MultithreadInfo::n_threads()),
vec_size / gs);
chunk_size = vec_size / n_chunks;
size_type vec_size = end-start;
// only go to the parallel function in case there are at least 4 parallel
// items, otherwise the overhead is too large
- if (vec_size >= 4*internal::Vector::minimum_parallel_grain_size &&
+ if (vec_size >= 4*internal::VectorImplementation::minimum_parallel_grain_size &&
MultithreadInfo::n_threads() > 1)
{
Assert(partitioner.get() != nullptr,
{
const size_type vec_size = end-start;
// set chunk size for sub-tasks
- const unsigned int gs = internal::Vector::minimum_parallel_grain_size;
+ const unsigned int gs = internal::VectorImplementation::minimum_parallel_grain_size;
n_chunks = std::min(static_cast<size_type>(4*MultithreadInfo::n_threads()),
vec_size / gs);
chunk_size = vec_size / n_chunks;
size_type vec_size = end-start;
// only go to the parallel function in case there are at least 4 parallel
// items, otherwise the overhead is too large
- if (vec_size >= 4*internal::Vector::minimum_parallel_grain_size &&
+ if (vec_size >= 4*internal::VectorImplementation::minimum_parallel_grain_size &&
MultithreadInfo::n_threads() > 1)
{
Assert(partitioner.get() != nullptr,
namespace internal
{
- namespace MatrixFree
+ namespace MatrixFreeImplementation
{
template <typename DoFHandlerType>
inline
quads.push_back (quad);
std::vector<IndexSet> locally_owned_sets =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handlers, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
constraints.push_back (&constraints_in);
std::vector<IndexSet> locally_owned_sets =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handlers, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
const typename MatrixFree<dim,Number>::AdditionalData additional_data)
{
std::vector<IndexSet> locally_owned_set =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handler, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
for (unsigned int q=0; q<quad.size(); ++q)
const typename MatrixFree<dim,Number>::AdditionalData additional_data)
{
std::vector<IndexSet> locally_owned_set =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handler, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
quad_hp.emplace_back (quad);
const typename MatrixFree<dim,Number>::AdditionalData additional_data)
{
std::vector<IndexSet> locally_owned_set =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handler, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
quad_hp.emplace_back (quad);
const typename MatrixFree<dim,Number>::AdditionalData additional_data)
{
std::vector<IndexSet> locally_owned_set =
- internal::MatrixFree::extract_locally_owned_index_sets
+ internal::MatrixFreeImplementation::extract_locally_owned_index_sets
(dof_handler, additional_data.level_mg_handler);
std::vector<hp::QCollection<1> > quad_hp;
for (unsigned int q=0; q<quad.size(); ++q)
namespace internal
{
- namespace PreconditionMG
+ namespace PreconditionMGImplementation
{
template <int dim, typename VectorType, class TRANSFER, typename OtherVectorType>
typename std::enable_if<TRANSFER::supports_dof_handler_vector>::type
(OtherVectorType &dst,
const OtherVectorType &src) const
{
- internal::PreconditionMG::vmult(dof_handler_vector_raw,*multigrid,*transfer,
- dst,src,uses_dof_handler_vector,0);
+ internal::PreconditionMGImplementation::vmult(dof_handler_vector_raw,*multigrid,*transfer,
+ dst,src,uses_dof_handler_vector,0);
}
(OtherVectorType &dst,
const OtherVectorType &src) const
{
- internal::PreconditionMG::vmult_add(dof_handler_vector_raw,*multigrid,*transfer,
- dst,src,uses_dof_handler_vector,0);
+ internal::PreconditionMGImplementation::vmult_add(dof_handler_vector_raw,*multigrid,*transfer,
+ dst,src,uses_dof_handler_vector,0);
}
namespace internal
{
- namespace DataOut
+ namespace DataOutImplementation
{
/**
* A derived class for use in the DataOut class. This is a class for the
*/
void build_one_patch
(const std::pair<cell_iterator, unsigned int> *cell_and_index,
- internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &scratch_data,
+ internal::DataOutImplementation::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &scratch_data,
const unsigned int n_subdivisions,
const CurvedCellRegion curved_cell_region);
};
* A namespace for exceptions that are used throughout the DataOut*
* collection of classes.
*/
- namespace DataOut
+ namespace DataOutImplementation
{
/**
* Exception
namespace internal
{
- namespace DataOut
+ namespace DataOutImplementation
{
/**
* The DataEntry classes abstract away the concrete data type of vectors
/**
* List of data elements with vectors of values for each degree of freedom.
*/
- std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > dof_data;
+ std::vector<std::shared_ptr<internal::DataOutImplementation::DataEntryBase<DoFHandlerType> > > dof_data;
/**
* List of data elements with vectors of values for each cell.
*/
- std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > > cell_data;
+ std::vector<std::shared_ptr<internal::DataOutImplementation::DataEntryBase<DoFHandlerType> > > cell_data;
/**
* This is a list of patches that is created each time build_patches() is
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
{
- Assert (triangulation != nullptr, Exceptions::DataOut::ExcNoTriangulationSelected ());
+ Assert (triangulation != nullptr, Exceptions::DataOutImplementation::ExcNoTriangulationSelected ());
std::vector<std::string> names(1, name);
add_data_vector_internal (dofs, vec, names, type, data_component_interpretation, true);
}
const DataVectorType type,
const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
{
- Assert (triangulation != nullptr, Exceptions::DataOut::ExcNoTriangulationSelected ());
+ Assert (triangulation != nullptr, Exceptions::DataOutImplementation::ExcNoTriangulationSelected ());
add_data_vector_internal(dofs, vec, names, type, data_component_interpretation, false);
}
add_data_vector (const VectorType &vec,
const DataPostprocessor<DoFHandlerType::space_dimension> &data_postprocessor)
{
- Assert (dofs != nullptr, Exceptions::DataOut::ExcNoDoFHandlerSelected ());
+ Assert (dofs != nullptr, Exceptions::DataOutImplementation::ExcNoDoFHandlerSelected ());
add_data_vector(*dofs, vec, data_postprocessor);
}
// check equality of component
// names
Assert (get_dataset_names() == source.get_dataset_names(),
- Exceptions::DataOut::ExcIncompatibleDatasetNames());
+ Exceptions::DataOutImplementation::ExcIncompatibleDatasetNames());
// make sure patches are compatible. we'll
// assume that if the first respective
// patches are ok that all the other ones
// are ok as well
Assert (patches[0].n_subdivisions == source_patches[0].n_subdivisions,
- Exceptions::DataOut::ExcIncompatiblePatchLists());
+ Exceptions::DataOutImplementation::ExcIncompatiblePatchLists());
Assert (patches[0].data.n_rows() == source_patches[0].data.n_rows(),
- Exceptions::DataOut::ExcIncompatiblePatchLists());
+ Exceptions::DataOutImplementation::ExcIncompatiblePatchLists());
Assert (patches[0].data.n_cols() == source_patches[0].data.n_cols(),
- Exceptions::DataOut::ExcIncompatiblePatchLists());
+ Exceptions::DataOutImplementation::ExcIncompatiblePatchLists());
// check equality of the vector data
// specifications
namespace internal
{
- namespace DataOut
+ namespace DataOutImplementation
{
template <int dim, int spacedim>
ParallelDataBase<dim,spacedim>::
namespace internal
{
- namespace DataOut
+ namespace DataOutImplementation
{
/**
* Extract the specified component of a number. This template is used
Assert (names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789_<>()") == std::string::npos,
- Exceptions::DataOut::ExcInvalidCharacter (names[i],
- names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789_<>()")));
+ Exceptions::DataOutImplementation::ExcInvalidCharacter (names[i],
+ names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "0123456789_<>()")));
}
Assert (names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789_<>()") == std::string::npos,
- Exceptions::DataOut::ExcInvalidCharacter (names[i],
- names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789_<>()")));
+ Exceptions::DataOutImplementation::ExcInvalidCharacter (names[i],
+ names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "0123456789_<>()")));
}
attach_dof_handler (const DoFHandlerType &d)
{
Assert (dof_data.size() == 0,
- Exceptions::DataOut::ExcOldDataStillPresent());
+ Exceptions::DataOutImplementation::ExcOldDataStillPresent());
Assert (cell_data.size() == 0,
- Exceptions::DataOut::ExcOldDataStillPresent());
+ Exceptions::DataOutImplementation::ExcOldDataStillPresent());
triangulation = SmartPointer<const Triangulation<DoFHandlerType::dimension,
DoFHandlerType::space_dimension> >
attach_triangulation (const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &tria)
{
Assert (dof_data.size() == 0,
- Exceptions::DataOut::ExcOldDataStillPresent());
+ Exceptions::DataOutImplementation::ExcOldDataStillPresent());
Assert (cell_data.size() == 0,
- Exceptions::DataOut::ExcOldDataStillPresent());
+ Exceptions::DataOutImplementation::ExcOldDataStillPresent());
triangulation = SmartPointer<const Triangulation<DoFHandlerType::dimension,
DoFHandlerType::space_dimension> >
}
Assert (vec.size() == dof_handler.n_dofs(),
- Exceptions::DataOut::ExcInvalidVectorSize (vec.size(),
- dof_handler.n_dofs(),
- dof_handler.get_triangulation().n_active_cells()));
+ Exceptions::DataOutImplementation::ExcInvalidVectorSize (vec.size(),
+ dof_handler.n_dofs(),
+ dof_handler.get_triangulation().n_active_cells()));
- auto new_entry = std_cxx14::make_unique<internal::DataOut::DataEntry<DoFHandlerType,VectorType>>
+ auto new_entry = std_cxx14::make_unique<internal::DataOutImplementation::DataEntry<DoFHandlerType,VectorType>>
(&dof_handler, &vec, &data_postprocessor);
dof_data.emplace_back (std::move(new_entry));
}
ExcDimensionMismatch (data_vector.size(),
triangulation->n_active_cells()));
Assert (deduced_names.size() == 1,
- Exceptions::DataOut::ExcInvalidNumberOfNames (deduced_names.size(), 1));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfNames (deduced_names.size(), 1));
break;
case type_dof_data:
Assert (dof_handler != nullptr,
- Exceptions::DataOut::ExcNoDoFHandlerSelected ());
+ Exceptions::DataOutImplementation::ExcNoDoFHandlerSelected ());
Assert (data_vector.size() == dof_handler->n_dofs(),
- Exceptions::DataOut::ExcInvalidVectorSize (data_vector.size(),
- dof_handler->n_dofs(),
- triangulation->n_active_cells()));
+ Exceptions::DataOutImplementation::ExcInvalidVectorSize (data_vector.size(),
+ dof_handler->n_dofs(),
+ triangulation->n_active_cells()));
Assert (deduced_names.size() == dof_handler->get_fe(0).n_components(),
- Exceptions::DataOut::ExcInvalidNumberOfNames (deduced_names.size(),
- dof_handler->get_fe(0).n_components()));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfNames (deduced_names.size(),
+ dof_handler->get_fe(0).n_components()));
break;
default:
Assert (false, ExcInternalError());
(deduced_names.size(), DataComponentInterpretation::component_is_scalar));
// finally, add the data vector:
- auto new_entry = std_cxx14::make_unique<internal::DataOut::DataEntry<DoFHandlerType,VectorType>>
+ auto new_entry = std_cxx14::make_unique<internal::DataOutImplementation::DataEntry<DoFHandlerType,VectorType>>
(dof_handler, &data_vector, deduced_names, data_component_interpretation);
if (actual_type == type_dof_data)
// collect the names of dof
// and cell data
typedef
- typename std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
+ typename std::vector<std::shared_ptr<internal::DataOutImplementation::DataEntryBase<DoFHandlerType> > >::const_iterator
data_iterator;
for (data_iterator d=dof_data.begin();
// collect the ranges of dof and cell data
typedef
- typename std::vector<std::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
+ typename std::vector<std::shared_ptr<internal::DataOutImplementation::DataEntryBase<DoFHandlerType> > >::const_iterator
data_iterator;
unsigned int output_component = 0;
// deal with vectors
Assert (i+patch_space_dim <=
(*d)->n_output_variables,
- Exceptions::DataOut::ExcInvalidVectorDeclaration (i,
- (*d)->names[i]));
+ Exceptions::DataOutImplementation::ExcInvalidVectorDeclaration (i,
+ (*d)->names[i]));
for (unsigned int dd=1; dd<patch_space_dim; ++dd)
Assert ((*d)->data_component_interpretation[i+dd]
==
DataComponentInterpretation::component_is_part_of_vector,
- Exceptions::DataOut::ExcInvalidVectorDeclaration (i,
- (*d)->names[i]));
+ Exceptions::DataOutImplementation::ExcInvalidVectorDeclaration (i,
+ (*d)->names[i]));
// all seems alright, so figure out
// whether there is a common name
for (unsigned int i=0; i<this->dof_data.size(); ++i)
{
Assert (dof_data[i]->dof_handler != nullptr,
- Exceptions::DataOut::ExcNoDoFHandlerSelected ());
+ Exceptions::DataOutImplementation::ExcNoDoFHandlerSelected ());
// avoid creating too many finite elements and doing a lot of work on
// initializing FEValues downstream: if two DoFHandlers are the same
namespace internal
{
- namespace DataOutFaces
+ namespace DataOutFacesImplementation
{
/**
* A derived class for use in the DataOutFaces class. This is a class for
* documentation of the WorkStream context.
*/
template <int dim, int spacedim>
- struct ParallelData : public internal::DataOut::ParallelDataBase<dim,spacedim>
+ struct ParallelData : public internal::DataOutImplementation::ParallelDataBase<dim,spacedim>
{
ParallelData (const unsigned int n_datasets,
const unsigned int n_subdivisions,
* Build one patch. This function is called in a WorkStream context.
*/
void build_one_patch (const FaceDescriptor *cell_and_face,
- internal::DataOutFaces::ParallelData<dimension, dimension> &data,
+ internal::DataOutFacesImplementation::ParallelData<dimension, dimension> &data,
DataOutBase::Patch<dimension-1,space_dimension> &patch);
};
namespace internal
{
- namespace DataOutRotation
+ namespace DataOutRotationImplementation
{
/**
* A derived class for use in the DataOutFaces class. This is a class for
* documentation of the WorkStream class.
*/
template <int dim, int spacedim>
- struct ParallelData : public internal::DataOut::ParallelDataBase<dim,spacedim>
+ struct ParallelData : public internal::DataOutImplementation::ParallelDataBase<dim,spacedim>
{
ParallelData (const unsigned int n_datasets,
const unsigned int n_subdivisions,
*/
void
build_one_patch (const cell_iterator *cell,
- internal::DataOutRotation::ParallelData<dimension, space_dimension> &data,
+ internal::DataOutRotationImplementation::ParallelData<dimension, space_dimension> &data,
std::vector<DataOutBase::Patch<dimension+1,space_dimension+1> > &my_patches);
};
namespace internal
{
- namespace PointValueHistory
+ namespace PointValueHistoryImplementation
{
/**
* A class that stores the data needed to reference the support points
/**
* Save the location and other mesh info about support points.
*/
- std::vector <internal::PointValueHistory::PointGeometryData <dim> >
+ std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >
point_geometry_data;
namespace internal
{
- namespace Vector
+ namespace VectorImplementation
{
// set minimum grain size. this value has been determined by experiments
// with the actual dealii::Vector implementation and takes vectorization
}
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
// set this value to 1/16 of the value of the minimum grain size of
// vectors (a factor of 4 because we assume that sparse matrix-vector
namespace internal
{
- namespace LagrangeEquidistant
+ namespace LagrangeEquidistantImplementation
{
std::vector<Point<1> >
generate_equidistant_unit_points (const unsigned int n)
LagrangeEquidistant::LagrangeEquidistant (const unsigned int n,
const unsigned int support_point)
:
- Polynomial<double> (internal::LagrangeEquidistant::
+ Polynomial<double> (internal::LagrangeEquidistantImplementation::
generate_equidistant_unit_points (n),
support_point)
{
namespace internal
{
- namespace QIterated
+ namespace QIteratedImplementation
{
namespace
{
QIterated<1>::QIterated (const Quadrature<1> &base_quadrature,
const unsigned int n_copies)
:
- Quadrature<1> (internal::QIterated::uses_both_endpoints(base_quadrature) ?
+ Quadrature<1> (internal::QIteratedImplementation::uses_both_endpoints(base_quadrature) ?
(base_quadrature.size()-1) * n_copies + 1 :
base_quadrature.size() * n_copies)
{
Assert (base_quadrature.size() > 0, ExcNotInitialized());
Assert (n_copies > 0, ExcZero());
- if (!internal::QIterated::uses_both_endpoints(base_quadrature))
+ if (!internal::QIteratedImplementation::uses_both_endpoints(base_quadrature))
// we don't have to skip some
// points in order to get a
// reasonable quadrature formula
namespace internal
\{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
\{
template
void
{
namespace internal
\{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
\{
template
struct Inverse<4,3,number>;
namespace internal
\{
- namespace SymmetricTensor
+ namespace SymmetricTensorImplementation
\{
template
std::array<std::pair<number, Tensor<1,2,number> >,2>
namespace internal
{
- namespace Timer
+ namespace TimerImplementation
{
namespace
{
#else
# warning "Unsupported platform. Porting not finished."
#endif
- return time_point(internal::Timer::from_seconds<duration>(system_cpu_duration));
+ return time_point(internal::TimerImplementation::from_seconds<duration>(system_cpu_duration));
}
cpu_times.last_lap_time = cpu_clock_type::now() - cpu_times.current_lap_start_time;
last_lap_wall_time_data = Utilities::MPI::min_max_avg
- (internal::Timer::to_seconds(wall_times.last_lap_time),
+ (internal::TimerImplementation::to_seconds(wall_times.last_lap_time),
mpi_communicator);
if (sync_lap_times)
{
- wall_times.last_lap_time = internal::Timer::from_seconds<decltype(wall_times)::duration_type>
+ wall_times.last_lap_time = internal::TimerImplementation::from_seconds<decltype(wall_times)::duration_type>
(last_lap_wall_time_data.max);
- cpu_times.last_lap_time = internal::Timer::from_seconds<decltype(cpu_times)::duration_type>
+ cpu_times.last_lap_time = internal::TimerImplementation::from_seconds<decltype(cpu_times)::duration_type>
(Utilities::MPI::min_max_avg
- (internal::Timer::to_seconds(cpu_times.last_lap_time),
+ (internal::TimerImplementation::to_seconds(cpu_times.last_lap_time),
mpi_communicator).max);
}
wall_times.accumulated_time += wall_times.last_lap_time;
cpu_times.accumulated_time += cpu_times.last_lap_time;
accumulated_wall_time_data = Utilities::MPI::min_max_avg
- (internal::Timer::to_seconds(wall_times.accumulated_time),
+ (internal::TimerImplementation::to_seconds(wall_times.accumulated_time),
mpi_communicator);
}
- return internal::Timer::to_seconds(cpu_times.accumulated_time);
+ return internal::TimerImplementation::to_seconds(cpu_times.accumulated_time);
}
{
if (running)
{
- const double running_time = internal::Timer::to_seconds
+ const double running_time = internal::TimerImplementation::to_seconds
(cpu_clock_type::now()
- cpu_times.current_lap_start_time
+ cpu_times.accumulated_time);
}
else
{
- return Utilities::MPI::sum (internal::Timer::to_seconds(cpu_times.accumulated_time),
+ return Utilities::MPI::sum (internal::TimerImplementation::to_seconds(cpu_times.accumulated_time),
mpi_communicator);
}
}
double Timer::last_cpu_time() const
{
- return internal::Timer::to_seconds(cpu_times.last_lap_time);
+ return internal::TimerImplementation::to_seconds(cpu_times.last_lap_time);
}
double Timer::get_lap_time() const
{
- return internal::Timer::to_seconds(wall_times.last_lap_time);
+ return internal::TimerImplementation::to_seconds(wall_times.last_lap_time);
}
else
current_elapsed_wall_time = wall_times.accumulated_time;
- return internal::Timer::to_seconds(current_elapsed_wall_time);
+ return internal::TimerImplementation::to_seconds(current_elapsed_wall_time);
}
double Timer::last_wall_time () const
{
- return internal::Timer::to_seconds(wall_times.last_lap_time);
+ return internal::TimerImplementation::to_seconds(wall_times.last_lap_time);
}
wall_times.reset();
cpu_times.reset();
running = false;
- internal::Timer::clear_timing_data(last_lap_wall_time_data);
- internal::Timer::clear_timing_data(accumulated_wall_time_data);
+ internal::TimerImplementation::clear_timing_data(last_lap_wall_time_data);
+ internal::TimerImplementation::clear_timing_data(accumulated_wall_time_data);
}
// release unused vector memory because we will have very different
// vectors now
- ::dealii::internal::GrowingVectorMemory::release_all_unused_memory();
+ ::dealii::internal::GrowingVectorMemoryImplementation::release_all_unused_memory();
}
#endif
}
{
// release unused vector memory because the vector layout is going to look
// very different now
- ::dealii::internal::GrowingVectorMemory::release_all_unused_memory();
+ ::dealii::internal::GrowingVectorMemoryImplementation::release_all_unused_memory();
}
template <int dim, int spacedim>
Assert (this->dof_handler != nullptr, typename BaseClass::ExcInvalidObject());
- internal::DoFCellAccessor::Implementation::
+ internal::DoFCellAccessorImplementation::Implementation::
update_cell_dof_indices_cache (*this);
}
Assert (this->dof_handler != nullptr, typename BaseClass::ExcInvalidObject());
- internal::DoFCellAccessor::Implementation::
+ internal::DoFCellAccessorImplementation::Implementation::
set_dof_indices (*this, local_dof_indices);
}
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
std::size_t
DoFFaces<1>::memory_consumption () const
namespace internal
{
template <int dim, int spacedim>
- std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy)
+ std::string policy_to_string(const dealii::internal::DoFHandlerImplementation::Policy::PolicyBase<dim,spacedim> &policy)
{
std::string policy_name;
- if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::Sequential<dealii::DoFHandler<dim,spacedim> >*>(&policy)
- || dynamic_cast<const typename dealii::internal::DoFHandler::Policy::Sequential<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
+ if (dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::Sequential<dealii::DoFHandler<dim,spacedim> >*>(&policy)
+ || dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::Sequential<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
policy_name = "Policy::Sequential<";
- else if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelDistributed<dealii::DoFHandler<dim,spacedim> >*>(&policy)
- || dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelDistributed<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
+ else if (dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::ParallelDistributed<dealii::DoFHandler<dim,spacedim> >*>(&policy)
+ || dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::ParallelDistributed<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
policy_name = "Policy::ParallelDistributed<";
- else if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelShared<dealii::DoFHandler<dim,spacedim> >*>(&policy)
- || dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelShared<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
+ else if (dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::ParallelShared<dealii::DoFHandler<dim,spacedim> >*>(&policy)
+ || dynamic_cast<const typename dealii::internal::DoFHandlerImplementation::Policy::ParallelShared<dealii::hp::DoFHandler<dim,spacedim> >*>(&policy))
policy_name = "Policy::ParallelShared<";
else
AssertThrow(false, ExcNotImplemented());
}
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
// access class
// dealii::DoFHandler instead of
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
- dof_handler.levels.emplace_back (new internal::DoFHandler::DoFLevel<1>);
+ dof_handler.levels.emplace_back (new internal::DoFHandlerImplementation::DoFLevel<1>);
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
- dof_handler.levels.emplace_back (new internal::DoFHandler::DoFLevel<2>);
+ dof_handler.levels.emplace_back (new internal::DoFHandlerImplementation::DoFLevel<2>);
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
numbers::invalid_dof_index);
}
- dof_handler.faces = std_cxx14::make_unique<internal::DoFHandler::DoFFaces<2>> ();
+ dof_handler.faces = std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>> ();
// avoid access to n_raw_lines when there are no cells
if (dof_handler.tria->n_cells() > 0)
{
for (unsigned int i=0; i<dof_handler.tria->n_levels(); ++i)
{
- dof_handler.levels.emplace_back (new internal::DoFHandler::DoFLevel<3>);
+ dof_handler.levels.emplace_back (new internal::DoFHandlerImplementation::DoFLevel<3>);
dof_handler.levels.back()->dof_object.dofs
.resize (dof_handler.tria->n_raw_cells(i) *
dof_handler.get_fe().dofs_per_cell,
numbers::invalid_dof_index);
}
- dof_handler.faces = std_cxx14::make_unique<internal::DoFHandler::DoFFaces<3>> ();
+ dof_handler.faces = std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>> ();
// avoid access to n_raw_lines when there are no cells
if (dof_handler.tria->n_cells() > 0)
for (unsigned int i = 0; i < n_levels; ++i)
{
- dof_handler.mg_levels.emplace_back (new internal::DoFHandler::DoFLevel<1>);
+ dof_handler.mg_levels.emplace_back (new internal::DoFHandlerImplementation::DoFLevel<1>);
dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines (i) * dofs_per_line, numbers::invalid_dof_index);
}
for (unsigned int i = 0; i < n_levels; ++i)
{
- dof_handler.mg_levels.emplace_back (std_cxx14::make_unique<internal::DoFHandler::DoFLevel<2>> ());
+ dof_handler.mg_levels.emplace_back (std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFLevel<2>> ());
dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads (i) * fe.dofs_per_quad, numbers::invalid_dof_index);
}
- dof_handler.mg_faces = std_cxx14::make_unique<internal::DoFHandler::DoFFaces<2>> ();
+ dof_handler.mg_faces = std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>> ();
dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, numbers::invalid_dof_index);
const unsigned int &n_vertices = tria.n_vertices ();
for (unsigned int i = 0; i < n_levels; ++i)
{
- dof_handler.mg_levels.emplace_back (std_cxx14::make_unique<internal::DoFHandler::DoFLevel<3>> ());
+ dof_handler.mg_levels.emplace_back (std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFLevel<3>> ());
dof_handler.mg_levels.back ()->dof_object.dofs = std::vector<types::global_dof_index> (tria.n_raw_hexs (i) * fe.dofs_per_hex, numbers::invalid_dof_index);
}
- dof_handler.mg_faces = std_cxx14::make_unique<internal::DoFHandler::DoFFaces<3>> ();
+ dof_handler.mg_faces = std_cxx14::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>> ();
dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index> (tria.n_raw_lines () * fe.dofs_per_line, numbers::invalid_dof_index);
dof_handler.mg_faces->quads.dofs = std::vector<types::global_dof_index> (tria.n_raw_quads () * fe.dofs_per_quad, numbers::invalid_dof_index);
types::global_dof_index
get_dof_index (
const DoFHandler<1, spacedim> &dof_handler,
- const std::unique_ptr<internal::DoFHandler::DoFLevel<1> > &mg_level,
- const std::unique_ptr<internal::DoFHandler::DoFFaces<1> > &,
+ const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<1> > &mg_level,
+ const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<1> > &,
const unsigned int obj_index,
const unsigned int fe_index,
const unsigned int local_index,
template <int spacedim>
static
types::global_dof_index
- get_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<2> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<2> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 1>)
+ get_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<2> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<2> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 1>)
{
return mg_faces->lines.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
template <int spacedim>
static
types::global_dof_index
- get_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<2> > &mg_level, const std::unique_ptr<internal::DoFHandler::DoFFaces<2> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 2>)
+ get_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<2> > &mg_level, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<2> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 2>)
{
return mg_level->dof_object.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
template <int spacedim>
static
types::global_dof_index
- get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 1>)
+ get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 1>)
{
return mg_faces->lines.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
template <int spacedim>
static
types::global_dof_index
- get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 2>)
+ get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 2>)
{
return mg_faces->quads.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
template <int spacedim>
static
types::global_dof_index
- get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &mg_level, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 3>)
+ get_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &mg_level, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const std::integral_constant<int, 3>)
{
return mg_level->dof_object.get_dof_index (dof_handler, obj_index, fe_index, local_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<1, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<1> > &mg_level, const std::unique_ptr<internal::DoFHandler::DoFFaces<1> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
+ void set_dof_index (const DoFHandler<1, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<1> > &mg_level, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<1> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
{
mg_level->dof_object.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<2> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<2> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
+ void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<2> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<2> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
{
mg_faces->lines.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<2> > &mg_level, const std::unique_ptr<internal::DoFHandler::DoFFaces<2> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 2>)
+ void set_dof_index (const DoFHandler<2, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<2> > &mg_level, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<2> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 2>)
{
mg_level->dof_object.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
+ void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 1>)
{
mg_faces->lines.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 2>)
+ void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &mg_faces, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 2>)
{
mg_faces->quads.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
template <int spacedim>
static
- void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandler::DoFLevel<3> > &mg_level, const std::unique_ptr<internal::DoFHandler::DoFFaces<3> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 3>)
+ void set_dof_index (const DoFHandler<3, spacedim> &dof_handler, const std::unique_ptr<internal::DoFHandlerImplementation::DoFLevel<3> > &mg_level, const std::unique_ptr<internal::DoFHandlerImplementation::DoFFaces<3> > &, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const types::global_dof_index global_index, const std::integral_constant<int, 3>)
{
mg_level->dof_object.set_dof_index (dof_handler, obj_index, fe_index, local_index, global_index);
}
if (dynamic_cast<const parallel::shared::Triangulation< dim, spacedim>*>
(&tria)
!= nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
else if (dynamic_cast<const parallel::distributed::Triangulation< dim, spacedim >*>
(&tria)
== nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
else
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
}
// decide whether we need a sequential or a parallel distributed policy
if (dynamic_cast<const parallel::shared::Triangulation< dim, spacedim>*> (&t) != nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
else if (dynamic_cast<const parallel::distributed::Triangulation< dim, spacedim >*> (&t) != nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
else
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
distribute_dofs(fe);
}
// know them on some cell (i.e. get
// back invalid_dof_index)
clear_space ();
- internal::DoFHandler::Implementation::reserve_space (*this);
+ internal::DoFHandlerImplementation::Implementation::reserve_space (*this);
// hand things off to the policy
number_cache = policy->distribute_dofs ();
clear_mg_space();
- internal::DoFHandler::Implementation::reserve_space_mg (*this);
+ internal::DoFHandlerImplementation::Implementation::reserve_space_mg (*this);
mg_number_cache = policy->distribute_mg_dofs ();
// initialize the block info object
unsigned int
DoFHandler<dim,spacedim>::max_couplings_between_dofs () const
{
- return internal::DoFHandler::Implementation::max_couplings_between_dofs (*this);
+ return internal::DoFHandlerImplementation::Implementation::max_couplings_between_dofs (*this);
}
const unsigned int fe_index,
const unsigned int local_index) const
{
- return internal::DoFHandler::Implementation::get_dof_index (*this, this->mg_levels[obj_level],
- this->mg_faces, obj_index,
- fe_index, local_index,
- std::integral_constant<int, structdim> ());
+ return internal::DoFHandlerImplementation::Implementation::get_dof_index (*this, this->mg_levels[obj_level],
+ this->mg_faces, obj_index,
+ fe_index, local_index,
+ std::integral_constant<int, structdim> ());
}
const unsigned int local_index,
const types::global_dof_index global_index) const
{
- internal::DoFHandler::Implementation::set_dof_index (*this,
- this->mg_levels[obj_level],
- this->mg_faces,
- obj_index,
- fe_index,
- local_index,
- global_index,
- std::integral_constant<int, structdim> ());
+ internal::DoFHandlerImplementation::Implementation::set_dof_index (*this,
+ this->mg_levels[obj_level],
+ this->mg_faces,
+ obj_index,
+ fe_index,
+ local_index,
+ global_index,
+ std::integral_constant<int, structdim> ());
}
namespace internal
\{
template const types::global_dof_index * dummy<deal_II_dimension,deal_II_dimension> ();
- template std::string policy_to_string(const dealii::internal::DoFHandler::Policy::
+ template std::string policy_to_string(const dealii::internal::DoFHandlerImplementation::Policy::
PolicyBase<deal_II_dimension,deal_II_dimension> &);
#if deal_II_dimension < 3
template const types::global_dof_index * dummy<deal_II_dimension,deal_II_dimension+1> ();
- template std::string policy_to_string(const dealii::internal::DoFHandler::Policy::
+ template std::string policy_to_string(const dealii::internal::DoFHandlerImplementation::Policy::
PolicyBase<deal_II_dimension,deal_II_dimension+1> &);
#endif
\}
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
namespace Policy
{
(include_vertex[vertex_index] == true))
{
const unsigned int n_active_fe_indices
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
n_active_vertex_fe_indices (dof_handler, vertex_index);
if (n_active_fe_indices > 1)
{
const unsigned int
first_fe_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
nth_active_vertex_fe_index (dof_handler, vertex_index, 0);
// loop over all the other FEs with which we want
{
const unsigned int
other_fe_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
nth_active_vertex_fe_index (dof_handler, vertex_index, f);
// make sure the entry in the equivalence
for (unsigned int i=0; i<identities.size(); ++i)
{
const types::global_dof_index lower_dof_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
get_vertex_dof_index (dof_handler,
vertex_index,
first_fe_index,
identities[i].first);
const types::global_dof_index higher_dof_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
get_vertex_dof_index (dof_handler,
vertex_index,
other_fe_index,
++vertex_index)
{
const unsigned int n_active_fe_indices
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
n_active_vertex_fe_indices (dof_handler, vertex_index);
// if this vertex is unused, then we really ought not to have allocated
for (unsigned int f=0; f<n_active_fe_indices; ++f)
{
const unsigned int fe_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
nth_active_vertex_fe_index (dof_handler, vertex_index, f);
for (unsigned int d=0; d<dof_handler.get_fe(fe_index).dofs_per_vertex; ++d)
{
const types::global_dof_index old_dof_index
- = dealii::internal::DoFAccessor::Implementation::
+ = dealii::internal::DoFAccessorImplementation::Implementation::
get_vertex_dof_index(dof_handler,
vertex_index,
fe_index,
ExcInternalError());
if (old_dof_index != numbers::invalid_dof_index)
- dealii::internal::DoFAccessor::Implementation::
+ dealii::internal::DoFAccessorImplementation::Implementation::
set_vertex_dof_index (dof_handler,
vertex_index,
fe_index,
#if deal_II_dimension <= deal_II_space_dimension
namespace internal
\{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
\{
namespace Policy
\{
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
template <int dim>
std::size_t
// explicit instantiations
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
#include "dof_objects.inst"
}
namespace internal
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
NumberCache::NumberCache ()
:
FiniteElement<dim,spacedim>::get_face_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
return get_data (flags, mapping,
QProjector<dim>::project_to_all_faces(quadrature),
FiniteElement<dim,spacedim>::get_subface_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
return get_data (flags, mapping,
QProjector<dim>::project_to_all_subfaces(quadrature),
get_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &,
const Quadrature<dim> &,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// generate a new data object
typename FiniteElement<dim,spacedim>::InternalDataBase *data
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
Assert (fe_internal.update_each & update_quadrature_points, ExcInternalError());
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
Assert (fe_internal.update_each & update_quadrature_points, ExcInternalError());
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
Assert (fe_internal.update_each & update_quadrature_points, ExcInternalError());
FE_Enriched<dim,spacedim>::get_face_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data) const
+ internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data) const
{
return setup_data(std::unique_ptr<typename FiniteElement<dim,spacedim>::InternalDataBase>(fe_system->get_face_data(update_flags,mapping,quadrature,output_data)),
update_flags,
FE_Enriched<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
return setup_data(std::unique_ptr<typename FiniteElement<dim,spacedim>::InternalDataBase>(fe_system->get_subface_data(update_flags,mapping,quadrature,output_data)),
update_flags,
FE_Enriched<dim,spacedim>::get_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data) const
+ internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data) const
{
return setup_data(std::unique_ptr<typename FiniteElement<dim,spacedim>::InternalDataBase>(fe_system->get_data(flags,mapping,quadrature,output_data)),
flags,
const Quadrature< dim > &quadrature,
const Mapping< dim, spacedim > &mapping,
const typename Mapping< dim, spacedim >::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData< dim, spacedim > &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data
+ internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data
) const
{
Assert (dynamic_cast<const InternalData *> (&fe_internal) != nullptr,
const Quadrature< dim-1 > &quadrature,
const Mapping< dim, spacedim > &mapping,
const typename Mapping< dim, spacedim >::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData< dim, spacedim > &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data
+ internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data
) const
{
Assert (dynamic_cast<const InternalData *> (&fe_internal) != nullptr,
const Quadrature< dim-1 > &quadrature,
const Mapping< dim, spacedim > &mapping,
const typename Mapping< dim, spacedim >::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData< dim, spacedim > &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- internal::FEValues::FiniteElementRelatedData< dim, spacedim > &output_data
+ internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > &output_data
) const
{
Assert (dynamic_cast<const InternalData *> (&fe_internal) != nullptr,
FE_Enriched<dim,spacedim>::multiply_by_enrichment
(const Quadrature<dim_1> &quadrature,
const InternalData &fe_data,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
const typename Triangulation< dim, spacedim >::cell_iterator &cell,
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data) const
{
// mapping_data will contain quadrature points on the real element.
// fe_internal is needed to get update flags
base_fe = base_element(base_no);
typename FiniteElement<dim,spacedim>::InternalDataBase &
base_fe_data = fe_data.get_fe_data(base_no);
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
base_data = fe_data.get_fe_output_object(base_no);
const UpdateFlags base_flags = base_fe_data.update_each;
template <int dim, int spacedim>
-internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
FE_Enriched<dim,spacedim>::
InternalData::get_fe_output_object (const unsigned int base_no) const
{
namespace internal
{
- namespace FE_FaceQ
+ namespace FE_FaceQImplementation
{
namespace
{
FE_FaceQ<dim,spacedim>::FE_FaceQ (const unsigned int degree)
:
FE_PolyFace<TensorProductPolynomials<dim-1>, dim, spacedim>
- (TensorProductPolynomials<dim-1>(Polynomials::generate_complete_Lagrange_basis(internal::FE_FaceQ::get_QGaussLobatto_points(degree))),
+ (TensorProductPolynomials<dim-1>(Polynomials::generate_complete_Lagrange_basis(internal::FE_FaceQImplementation::get_QGaussLobatto_points(degree))),
FiniteElementData<dim>(get_dpo_vector(degree), 1, degree, FiniteElementData<dim>::L2),
std::vector<bool>(1,true))
{
this->unit_face_support_points[0][d] = 0.5;
else
{
- std::vector<Point<1> > points = internal::FE_FaceQ::get_QGaussLobatto_points(degree);
+ std::vector<Point<1> > points = internal::FE_FaceQImplementation::get_QGaussLobatto_points(degree);
unsigned int k=0;
for (unsigned int iz=0; iz <= ((codim>2) ? this->degree : 0) ; ++iz)
const Quadrature<1> &,
const Mapping<1,spacedim> &,
const typename Mapping<1,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &,
const typename FiniteElement<1,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &) const
{
// Do nothing, since we do not have values in the interior
}
const Quadrature<0> &,
const Mapping<1,spacedim> &,
const typename Mapping<1,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &,
const typename FiniteElement<1,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &output_data) const
{
const unsigned int foffset = face;
if (fe_internal.update_each & update_values)
const Quadrature<0> &,
const Mapping<1,spacedim> &,
const typename Mapping<1,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<1, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1, spacedim> &,
const typename FiniteElement<1,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<1, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1, spacedim> &) const
{
Assert(false, ExcMessage("There are no sub-face values to fill in 1D!"));
}
FE_Nothing<dim,spacedim>::get_data (const UpdateFlags /*update_flags*/,
const Mapping<dim,spacedim> &/*mapping*/,
const Quadrature<dim> &/*quadrature*/,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// Create a default data object. Normally we would then
// need to resize things to hold the appropriate numbers
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &) const
{
// leave data fields empty
}
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &) const
{
// leave data fields empty
}
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &,
const typename FiniteElement<dim,spacedim>::InternalDataBase &,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &) const
{
// leave data fields empty
}
FE_P1NC::get_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<2> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
FiniteElement<2,2>::InternalDataBase *data = new FiniteElement<2,2>::InternalDataBase;
FE_P1NC::get_face_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
FiniteElement<2,2>::InternalDataBase *data = new FiniteElement<2,2>::InternalDataBase;
FE_P1NC::get_subface_data (const UpdateFlags update_flags,
const Mapping<2,2> &,
const Quadrature<1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
FiniteElement<2,2>::InternalDataBase *data = new FiniteElement<2,2>::InternalDataBase;
const Quadrature<2> &,
const Mapping<2,2> &,
const Mapping<2,2>::InternalDataBase &,
- const internal::FEValues::MappingRelatedData<2,2> &mapping_data,
+ const internal::FEValuesImplementation::MappingRelatedData<2,2> &mapping_data,
const FiniteElement<2,2>::InternalDataBase &fe_internal,
- internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
const UpdateFlags flags(fe_internal.update_each);
const Quadrature<1> &quadrature,
const Mapping<2,2> &mapping,
const Mapping<2,2>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<2,2> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,2> &,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
const UpdateFlags flags(fe_internal.update_each);
const Quadrature<1> &quadrature,
const Mapping<2,2> &mapping,
const Mapping<2,2>::InternalDataBase &,
- const dealii::internal::FEValues::MappingRelatedData<2,2> &,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,2> &,
const InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,2> &output_data) const
{
const UpdateFlags flags(fe_internal.update_each);
const Quadrature<1> &quadrature,
const Mapping<1,2> &mapping,
const Mapping<1,2>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<1,2> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1,2> &mapping_data,
const FiniteElement<1,2>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,2> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<2> &quadrature,
const Mapping<2,3> &mapping,
const Mapping<2,3>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<2,3> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,3> &mapping_data,
const FiniteElement<2,3>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,3> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,3> &output_data) const
{
// assert that the following dynamics
const Quadrature<1> &quadrature,
const Mapping<1,2> &mapping,
const Mapping<1,2>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<1,2> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<1,2> &mapping_data,
const FiniteElement<1,2>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<1,2> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<1,2> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<2> &quadrature,
const Mapping<2,3> &mapping,
const Mapping<2,3>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<2,3> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<2,3> &mapping_data,
const FiniteElement<2,3>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<2,3> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2,3> &output_data) const
{
Assert (dynamic_cast<const InternalData *> (&fe_internal) != nullptr, ExcInternalError());
const InternalData &fe_data = static_cast<const InternalData &> (fe_internal);
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
namespace internal
{
- namespace FESystem
+ namespace FESystemImplementation
{
namespace
{
template <int dim, int spacedim>
-internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
FESystem<dim,spacedim>::
InternalData::get_fe_output_object (const unsigned int base_no) const
{
FiniteElement<dim,spacedim> (FETools::Compositing::multiply_dof_numbers(fes, multiplicities),
FETools::Compositing::compute_restriction_is_additive_flags (fes, multiplicities),
FETools::Compositing::compute_nonzero_components(fes, multiplicities)),
- base_elements(internal::FESystem::count_nonzeros(multiplicities))
+ base_elements(internal::FESystemImplementation::count_nonzeros(multiplicities))
{
initialize(fes, multiplicities);
}
get_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// create an internal data object and set the update flags we will need
// to deal with. the current object does not make use of these flags,
// function is called
for (unsigned int base_no=0; base_no<this->n_base_elements(); ++base_no)
{
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
= data->get_fe_output_object(base_no);
base_fe_output_object.initialize (quadrature.size(), base_element(base_no),
flags | base_element(base_no).requires_update_flags(flags));
get_face_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// create an internal data object and set the update flags we will need
// to deal with. the current object does not make use of these flags,
// function is called
for (unsigned int base_no=0; base_no<this->n_base_elements(); ++base_no)
{
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
= data->get_fe_output_object(base_no);
base_fe_output_object.initialize (quadrature.size(), base_element(base_no),
flags | base_element(base_no).requires_update_flags(flags));
get_subface_data (const UpdateFlags flags,
const Mapping<dim,spacedim> &mapping,
const Quadrature<dim-1> &quadrature,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &/*output_data*/) const
{
// create an internal data object and set the update flags we will need
// to deal with. the current object does not make use of these flags,
// function is called
for (unsigned int base_no=0; base_no<this->n_base_elements(); ++base_no)
{
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &base_fe_output_object
= data->get_fe_output_object(base_no);
base_fe_output_object.initialize (quadrature.size(), base_element(base_no),
flags | base_element(base_no).requires_update_flags(flags));
const Quadrature<dim> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
compute_fill(mapping, cell, invalid_face_number, invalid_face_number,
quadrature, cell_similarity, mapping_internal, fe_internal,
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
compute_fill (mapping, cell, face_no, invalid_face_number, quadrature,
CellSimilarity::none, mapping_internal, fe_internal,
const Quadrature<dim-1> &quadrature,
const Mapping<dim,spacedim> &mapping,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
- const dealii::internal::FEValues::MappingRelatedData<dim, spacedim> &mapping_data,
+ const dealii::internal::FEValuesImplementation::MappingRelatedData<dim, spacedim> &mapping_data,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- dealii::internal::FEValues::FiniteElementRelatedData<dim, spacedim> &output_data) const
+ dealii::internal::FEValuesImplementation::FiniteElementRelatedData<dim, spacedim> &output_data) const
{
compute_fill (mapping, cell, face_no, sub_no, quadrature,
CellSimilarity::none, mapping_internal, fe_internal,
const CellSimilarity::Similarity cell_similarity,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_internal,
const typename FiniteElement<dim,spacedim>::InternalDataBase &fe_internal,
- const internal::FEValues::MappingRelatedData<dim,spacedim> &mapping_data,
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &output_data) const
+ const internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &mapping_data,
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
base_fe = base_element(base_no);
typename FiniteElement<dim,spacedim>::InternalDataBase &
base_fe_data = fe_data.get_fe_data(base_no);
- internal::FEValues::FiniteElementRelatedData<dim,spacedim> &
+ internal::FEValuesImplementation::FiniteElementRelatedData<dim,spacedim> &
base_data = fe_data.get_fe_output_object(base_no);
// fill_fe_face_values needs argument Quadrature<dim-1> for both cases
ExcDimensionMismatch (fes.size(), multiplicities.size()) );
Assert (fes.size() > 0,
ExcMessage ("Need to pass at least one finite element."));
- Assert (internal::FESystem::count_nonzeros(multiplicities) > 0,
+ Assert (internal::FESystemImplementation::count_nonzeros(multiplicities) > 0,
ExcMessage("You only passed FiniteElements with multiplicity 0."));
// Note that we need to skip every fe with multiplicity 0 in the following block of code
namespace internal
{
- namespace FEValues
+ namespace FEValuesImplementation
{
template <int dim, int spacedim>
void
namespace internal
\{
- namespace FEValues
+ namespace FEValuesImplementation
\{
template class MappingRelatedData<deal_II_dimension, deal_II_space_dimension>;
template class FiniteElementRelatedData<deal_II_dimension, deal_II_space_dimension>;
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with
// an exception if that is not possible
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal
// data for this class. fails with
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with
// an exception if that is not possible
namespace internal
{
- namespace MappingFEField
+ namespace MappingFEFieldImplementation
{
namespace
{
const unsigned int subface_no,
const std::vector<double> &weights,
const typename dealii::MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData &data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
const UpdateFlags update_flags = data.update_each;
const FiniteElement<dim, spacedim> &fe,
const ComponentMask &fe_mask,
const std::vector<unsigned int> &fe_to_real,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
maybe_compute_q_points<dim,spacedim,VectorType,DoFHandlerType>
(data_set,
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
update_internal_dofs(cell, data);
- internal::MappingFEField::maybe_compute_q_points<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_compute_q_points<dim,spacedim,VectorType,DoFHandlerType>
(QProjector<dim>::DataSetDescriptor::cell (),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
output_data.quadrature_points);
- internal::MappingFEField::maybe_update_Jacobians<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_Jacobians<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real);
}
// calculate derivatives of the Jacobians
- internal::MappingFEField::maybe_update_jacobian_grads<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_grads<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
output_data.jacobian_grads);
// calculate derivatives of the Jacobians pushed forward to real cell coordinates
- internal::MappingFEField::maybe_update_jacobian_pushed_forward_grads<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_pushed_forward_grads<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
output_data.jacobian_pushed_forward_grads);
// calculate hessians of the Jacobians
- internal::MappingFEField::maybe_update_jacobian_2nd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_2nd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
output_data.jacobian_2nd_derivatives);
// calculate hessians of the Jacobians pushed forward to real cell coordinates
- internal::MappingFEField::maybe_update_jacobian_pushed_forward_2nd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_pushed_forward_2nd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
output_data.jacobian_pushed_forward_2nd_derivatives);
// calculate gradients of the hessians of the Jacobians
- internal::MappingFEField::maybe_update_jacobian_3rd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_3rd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
// calculate gradients of the hessians of the Jacobians pushed forward to real
// cell coordinates
- internal::MappingFEField::maybe_update_jacobian_pushed_forward_3rd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::maybe_update_jacobian_pushed_forward_3rd_derivatives<dim,spacedim,VectorType,DoFHandlerType>
(cell_similarity,
QProjector<dim>::DataSetDescriptor::cell(),
data, euler_dof_handler->get_fe(), fe_mask, fe_to_real,
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
update_internal_dofs(cell, data);
- internal::MappingFEField::do_fill_fe_face_values<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::do_fill_fe_face_values<dim,spacedim,VectorType,DoFHandlerType>
(*this,
cell, face_no, numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
update_internal_dofs(cell, data);
- internal::MappingFEField::do_fill_fe_face_values<dim,spacedim,VectorType,DoFHandlerType>
+ internal::MappingFEFieldImplementation::do_fill_fe_face_values<dim,spacedim,VectorType,DoFHandlerType>
(*this,
cell, face_no, numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::
namespace internal
{
- namespace MappingFEField
+ namespace MappingFEFieldImplementation
{
namespace
{
{
AssertDimension (input.size(), output.size());
- internal::MappingFEField::transform_fields<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
+ internal::MappingFEFieldImplementation::transform_fields<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
}
{
AssertDimension (input.size(), output.size());
- internal::MappingFEField::transform_differential_forms<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
+ internal::MappingFEFieldImplementation::transform_differential_forms<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
}
namespace internal
{
- namespace MappingManifold
+ namespace MappingManifoldImplementation
{
namespace
{
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following static_cast is really correct:
Assert (dynamic_cast<const InternalData *>(&internal_data) != nullptr,
data.store_vertices(cell);
data.manifold = &(cell->get_manifold());
- internal::MappingManifold::maybe_compute_q_points<dim,spacedim>
+ internal::MappingManifoldImplementation::maybe_compute_q_points<dim,spacedim>
(QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.quadrature_points);
- internal::MappingManifold::maybe_update_Jacobians<dim,spacedim>
+ internal::MappingManifoldImplementation::maybe_update_Jacobians<dim,spacedim>
(QProjector<dim>::DataSetDescriptor::cell (),
data);
namespace internal
{
- namespace MappingManifold
+ namespace MappingManifoldImplementation
{
namespace
{
const unsigned int n_q_points,
const std::vector<double> &weights,
const typename dealii::MappingManifold<dim,spacedim>::InternalData &data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
const UpdateFlags update_flags = data.update_each;
const typename QProjector<dim>::DataSetDescriptor data_set,
const Quadrature<dim-1> &quadrature,
const typename dealii::MappingManifold<dim,spacedim>::InternalData &data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
data.store_vertices(cell);
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following cast is really correct:
Assert ((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
const InternalData &data
= static_cast<const InternalData &>(internal_data);
- internal::MappingManifold::do_fill_fe_face_values
+ internal::MappingManifoldImplementation::do_fill_fe_face_values
(*this,
cell, face_no, numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::face (face_no,
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following cast is really correct:
Assert ((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
const InternalData &data
= static_cast<const InternalData &>(internal_data);
- internal::MappingManifold::do_fill_fe_face_values
+ internal::MappingManifoldImplementation::do_fill_fe_face_values
(*this,
cell, face_no, subface_no,
QProjector<dim>::DataSetDescriptor::subface (face_no, subface_no,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim> > &output) const
{
- internal::MappingManifold::transform_fields(input, mapping_type, mapping_data, output);
+ internal::MappingManifoldImplementation::transform_fields(input, mapping_type, mapping_data, output);
}
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim> > &output) const
{
- internal::MappingManifold::transform_differential_forms(input, mapping_type, mapping_data, output);
+ internal::MappingManifoldImplementation::transform_differential_forms(input, mapping_type, mapping_data, output);
}
switch (mapping_type)
{
case mapping_contravariant:
- internal::MappingManifold::transform_fields(input, mapping_type, mapping_data, output);
+ internal::MappingManifoldImplementation::transform_fields(input, mapping_type, mapping_data, output);
return;
case mapping_piola_gradient:
case mapping_contravariant_gradient:
case mapping_covariant_gradient:
- internal::MappingManifold::transform_gradients(input, mapping_type, mapping_data, output);
+ internal::MappingManifoldImplementation::transform_gradients(input, mapping_type, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
case mapping_piola_hessian:
case mapping_contravariant_hessian:
case mapping_covariant_hessian:
- internal::MappingManifold::transform_hessians(input, mapping_type, mapping_data, output);
+ internal::MappingManifoldImplementation::transform_hessians(input, mapping_type, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// convert data object to internal data for this class. fails with an
// exception if that is not possible
const CellSimilarity::Similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// call the function of the base class, but ignoring
// any potentially detected cell similarity between
const CellSimilarity::Similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// call the function of the base class, but ignoring
// any potentially detected cell similarity between
namespace internal
{
- namespace MappingQGeneric
+ namespace MappingQGenericImplementation
{
namespace
{
const std::vector<unsigned int>
renumber (FETools::
lexicographic_to_hierarchic_numbering
- (FiniteElementData<dim> (internal::MappingQGeneric::get_dpo_vector<dim>
+ (FiniteElementData<dim> (internal::MappingQGenericImplementation::get_dpo_vector<dim>
(data.polynomial_degree), 1, data.polynomial_degree)));
std::vector<double> values;
const unsigned int n_shape_values = fe.n_dofs_per_cell();
const unsigned int max_size = std::max(n_q_points,n_shape_values);
- const unsigned int vec_length = VectorizedArray<double>::n_array_elements;
+ const unsigned int vec_length = dealii::VectorizedArray<double>::n_array_elements;
const unsigned int n_comp = 1+ (spacedim-1)/vec_length;
scratch.resize((dim-1)*max_size);
namespace internal
{
- namespace MappingQGeneric
+ namespace MappingQGenericImplementation
{
namespace
{
mdata.compute_shape_function_values(std::vector<Point<dim> > (1, p_unit_trial));
// f(x)
- Point<spacedim> p_real_trial = internal::MappingQGeneric::compute_mapped_location_of_point<dim,spacedim>(mdata);
+ Point<spacedim> p_real_trial = internal::MappingQGenericImplementation::compute_mapped_location_of_point<dim,spacedim>(mdata);
const Tensor<1,spacedim> f_trial = p_real_trial-p;
#ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL
polynomial_degree(p),
line_support_points(this->polynomial_degree+1),
fe_q(dim == 3 ? new FE_Q<dim>(this->polynomial_degree) : nullptr),
- support_point_weights_perimeter_to_interior (internal::MappingQGeneric::compute_support_point_weights_perimeter_to_interior(this->polynomial_degree, dim)),
- support_point_weights_cell (internal::MappingQGeneric::compute_support_point_weights_cell<dim>(this->polynomial_degree))
+ support_point_weights_perimeter_to_interior (internal::MappingQGenericImplementation::compute_support_point_weights_perimeter_to_interior(this->polynomial_degree, dim)),
+ support_point_weights_cell (internal::MappingQGenericImplementation::compute_support_point_weights_cell<dim>(this->polynomial_degree))
{
Assert (p >= 1, ExcMessage ("It only makes sense to create polynomial mappings "
"with a polynomial degree greater or equal to one."));
const std::vector<unsigned int>
renumber (FETools::
lexicographic_to_hierarchic_numbering
- (FiniteElementData<dim> (internal::MappingQGeneric::get_dpo_vector<dim>
+ (FiniteElementData<dim> (internal::MappingQGenericImplementation::get_dpo_vector<dim>
(polynomial_degree), 1, polynomial_degree)));
const std::vector<Point<spacedim> > support_points
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
- return internal::MappingQGeneric::do_transform_real_to_unit_cell_internal<1>(cell, p, initial_p_unit, *mdata);
+ return internal::MappingQGenericImplementation::do_transform_real_to_unit_cell_internal<1>(cell, p, initial_p_unit, *mdata);
}
template <>
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
- return internal::MappingQGeneric::do_transform_real_to_unit_cell_internal<2>(cell, p, initial_p_unit, *mdata);
+ return internal::MappingQGenericImplementation::do_transform_real_to_unit_cell_internal<2>(cell, p, initial_p_unit, *mdata);
}
template <>
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
- return internal::MappingQGeneric::do_transform_real_to_unit_cell_internal<3>(cell, p, initial_p_unit, *mdata);
+ return internal::MappingQGenericImplementation::do_transform_real_to_unit_cell_internal<3>(cell, p, initial_p_unit, *mdata);
}
template <>
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
- return internal::MappingQGeneric::do_transform_real_to_unit_cell_internal_codim1<1>(cell, p, initial_p_unit, *mdata);
+ return internal::MappingQGenericImplementation::do_transform_real_to_unit_cell_internal_codim1<1>(cell, p, initial_p_unit, *mdata);
}
template <>
// dispatch to the various specializations for spacedim=dim,
// spacedim=dim+1, etc
- return internal::MappingQGeneric::do_transform_real_to_unit_cell_internal_codim1<2>(cell, p, initial_p_unit, *mdata);
+ return internal::MappingQGenericImplementation::do_transform_real_to_unit_cell_internal_codim1<2>(cell, p, initial_p_unit, *mdata);
}
template <>
const CellSimilarity::Similarity cell_similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following static_cast is really correct:
Assert (dynamic_cast<const InternalData *>(&internal_data) != nullptr,
if (dim>1 && data.tensor_product_quadrature)
{
- internal::MappingQGeneric::maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>
+ internal::MappingQGenericImplementation::maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>
(computed_cell_similarity,
data,
output_data.quadrature_points,
}
else
{
- internal::MappingQGeneric::maybe_compute_q_points<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_compute_q_points<dim,spacedim>
(QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.quadrature_points);
- internal::MappingQGeneric::maybe_update_Jacobians<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_Jacobians<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data);
- internal::MappingQGeneric::maybe_update_jacobian_grads<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_grads<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.jacobian_grads);
}
- internal::MappingQGeneric::maybe_update_jacobian_pushed_forward_grads<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_pushed_forward_grads<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.jacobian_pushed_forward_grads);
- internal::MappingQGeneric::maybe_update_jacobian_2nd_derivatives<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_2nd_derivatives<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.jacobian_2nd_derivatives);
- internal::MappingQGeneric::maybe_update_jacobian_pushed_forward_2nd_derivatives<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_pushed_forward_2nd_derivatives<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.jacobian_pushed_forward_2nd_derivatives);
- internal::MappingQGeneric::maybe_update_jacobian_3rd_derivatives<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_3rd_derivatives<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
output_data.jacobian_3rd_derivatives);
- internal::MappingQGeneric::maybe_update_jacobian_pushed_forward_3rd_derivatives<dim,spacedim>
+ internal::MappingQGenericImplementation::maybe_update_jacobian_pushed_forward_3rd_derivatives<dim,spacedim>
(computed_cell_similarity,
QProjector<dim>::DataSetDescriptor::cell (),
data,
namespace internal
{
- namespace MappingQGeneric
+ namespace MappingQGenericImplementation
{
namespace
{
const unsigned int n_q_points,
const std::vector<double> &weights,
const typename dealii::MappingQGeneric<dim,spacedim>::InternalData &data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
const UpdateFlags update_flags = data.update_each;
const typename QProjector<dim>::DataSetDescriptor data_set,
const Quadrature<dim-1> &quadrature,
const typename dealii::MappingQGeneric<dim,spacedim>::InternalData &data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data)
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data)
{
if (dim>1 && data.tensor_product_quadrature)
{
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following cast is really correct:
Assert ((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
data.cell_of_current_support_points = cell;
}
- internal::MappingQGeneric::do_fill_fe_face_values
+ internal::MappingQGenericImplementation::do_fill_fe_face_values
(*this,
cell, face_no, numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::face (face_no,
const unsigned int subface_no,
const Quadrature<dim-1> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
- internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
+ internal::FEValuesImplementation::MappingRelatedData<dim,spacedim> &output_data) const
{
// ensure that the following cast is really correct:
Assert ((dynamic_cast<const InternalData *>(&internal_data) != nullptr),
data.cell_of_current_support_points = cell;
}
- internal::MappingQGeneric::do_fill_fe_face_values
+ internal::MappingQGenericImplementation::do_fill_fe_face_values
(*this,
cell, face_no, subface_no,
QProjector<dim>::DataSetDescriptor::subface (face_no, subface_no,
namespace internal
{
- namespace MappingQGeneric
+ namespace MappingQGenericImplementation
{
namespace
{
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<1, spacedim> > &output) const
{
- internal::MappingQGeneric::transform_fields(input, mapping_type, mapping_data, output);
+ internal::MappingQGenericImplementation::transform_fields(input, mapping_type, mapping_data, output);
}
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2, spacedim> > &output) const
{
- internal::MappingQGeneric::transform_differential_forms(input, mapping_type, mapping_data, output);
+ internal::MappingQGenericImplementation::transform_differential_forms(input, mapping_type, mapping_data, output);
}
switch (mapping_type)
{
case mapping_contravariant:
- internal::MappingQGeneric::transform_fields(input, mapping_type, mapping_data, output);
+ internal::MappingQGenericImplementation::transform_fields(input, mapping_type, mapping_data, output);
return;
case mapping_piola_gradient:
case mapping_contravariant_gradient:
case mapping_covariant_gradient:
- internal::MappingQGeneric::transform_gradients(input, mapping_type, mapping_data, output);
+ internal::MappingQGenericImplementation::transform_gradients(input, mapping_type, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
case mapping_piola_hessian:
case mapping_contravariant_hessian:
case mapping_covariant_hessian:
- internal::MappingQGeneric::transform_hessians(input, mapping_type, mapping_data, output);
+ internal::MappingQGenericImplementation::transform_hessians(input, mapping_type, mapping_data, output);
return;
default:
Assert(false, ExcNotImplemented());
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
NumberCache<1>::NumberCache ()
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
// make sure that if in the following we
// write Triangulation<dim,spacedim>
// we mean the *class*
// dealii::Triangulation, not the
// enclosing namespace
- // internal::Triangulation
+ // internal::TriangulationImplementation
using dealii::Triangulation;
/**
static
void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
const unsigned int level_objects,
- internal::Triangulation::NumberCache<1> &number_cache)
+ internal::TriangulationImplementation::NumberCache<1> &number_cache)
{
typedef
typename Triangulation<dim,spacedim>::line_iterator line_iterator;
static
void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
const unsigned int level_objects,
- internal::Triangulation::NumberCache<2> &number_cache)
+ internal::TriangulationImplementation::NumberCache<2> &number_cache)
{
// update lines and n_levels in number_cache. since we don't
// access any of these numbers, we can do this in the
Threads::Task<void> update_lines
= Threads::new_task ((void (*)(const Triangulation<dim,spacedim> &,
const unsigned int,
- internal::Triangulation::NumberCache<1> &))
+ internal::TriangulationImplementation::NumberCache<1> &))
(&compute_number_cache<dim,spacedim>),
triangulation,
level_objects,
- static_cast<internal::Triangulation::NumberCache<1>&>
+ static_cast<internal::TriangulationImplementation::NumberCache<1>&>
(number_cache));
typedef
static
void compute_number_cache (const Triangulation<dim,spacedim> &triangulation,
const unsigned int level_objects,
- internal::Triangulation::NumberCache<3> &number_cache)
+ internal::TriangulationImplementation::NumberCache<3> &number_cache)
{
// update quads, lines and n_levels in number_cache. since we
// don't access any of these numbers, we can do this in the
Threads::Task<void> update_quads_and_lines
= Threads::new_task ((void (*)(const Triangulation<dim,spacedim> &,
const unsigned int,
- internal::Triangulation::NumberCache<2> &))
+ internal::TriangulationImplementation::NumberCache<2> &))
(&compute_number_cache<dim,spacedim>),
triangulation,
level_objects,
- static_cast<internal::Triangulation::NumberCache<2>&>
+ static_cast<internal::TriangulationImplementation::NumberCache<2>&>
(number_cache));
typedef
std::vector<std::vector<int> > lines_at_vertex (v.size());
// reserve enough space
- triangulation.levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
+ triangulation.levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
triangulation.levels[0]->reserve_space (cells.size(), dim, spacedim);
triangulation.levels[0]->cells.reserve_space (0, cells.size());
while (next_free_line->used())
++next_free_line;
- next_free_line->set (internal::Triangulation
+ next_free_line->set (internal::TriangulationImplementation
::TriaObject<1> (cells[cell].vertices[0],
cells[cell].vertices[1]));
next_free_line->set_used_flag ();
}
// reserve enough space
- triangulation.levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
- triangulation.faces = std_cxx14::make_unique<internal::Triangulation::TriaFaces<dim>> ();
+ triangulation.levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
+ triangulation.faces = std_cxx14::make_unique<internal::TriangulationImplementation::TriaFaces<dim>> ();
triangulation.levels[0]->reserve_space (cells.size(), dim, spacedim);
triangulation.faces->lines.reserve_space (0,needed_lines.size());
triangulation.levels[0]->cells.reserve_space (0,cells.size());
for (i = needed_lines.begin();
line!=triangulation.end_line(); ++line, ++i)
{
- line->set (internal::Triangulation::TriaObject<1>(i->first.first,
- i->first.second));
+ line->set (internal::TriangulationImplementation::TriaObject<1>(i->first.first,
+ i->first.second));
line->set_used_flag ();
line->clear_user_flag ();
line->clear_user_data ();
cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 0)],
cells[c].vertices[GeometryInfo<dim>::line_to_cell_vertices(line, 1)])];
- cell->set (internal::Triangulation::TriaObject<2> (lines[0]->index(),
- lines[1]->index(),
- lines[2]->index(),
- lines[3]->index()));
+ cell->set (internal::TriangulationImplementation::TriaObject<2> (lines[0]->index(),
+ lines[1]->index(),
+ lines[2]->index(),
+ lines[3]->index()));
cell->set_used_flag ();
cell->set_material_id (cells[c].material_id);
/**
- * Invent an object which compares two internal::Triangulation::TriaObject<2>
+ * Invent an object which compares two internal::TriangulationImplementation::TriaObject<2>
* against each other. This comparison is needed in order to establish a map
* of TriaObject<2> to iterators in the Triangulation<3,3>::create_triangulation
* function.
*
* Since this comparison is not canonical, we do not include it into the
- * general internal::Triangulation::TriaObject<2> class.
+ * general internal::TriangulationImplementation::TriaObject<2> class.
*/
struct QuadComparator
{
- inline bool operator () (const internal::Triangulation::TriaObject<2> &q1,
- const internal::Triangulation::TriaObject<2> &q2) const
+ inline bool operator () (const internal::TriangulationImplementation::TriaObject<2> &q1,
+ const internal::TriangulationImplementation::TriaObject<2> &q2) const
{
// here is room to
// optimize the repeated
// actually set up data structures
// for the lines
// reserve enough space
- triangulation.levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
- triangulation.faces = std_cxx14::make_unique<internal::Triangulation::TriaFaces<dim>> ();
+ triangulation.levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
+ triangulation.faces = std_cxx14::make_unique<internal::TriangulationImplementation::TriaFaces<dim>> ();
triangulation.levels[0]->reserve_space (cells.size(), dim, spacedim);
triangulation.faces->lines.reserve_space (0,needed_lines.size());
typename Triangulation<dim,spacedim>::line_iterator>::iterator i;
for (i = needed_lines.begin(); line!=triangulation.end_line(); ++line, ++i)
{
- line->set (internal::Triangulation::TriaObject<1>(i->first.first,
- i->first.second));
+ line->set (internal::TriangulationImplementation::TriaObject<1>(i->first.first,
+ i->first.second));
line->set_used_flag ();
line->clear_user_flag ();
line->clear_user_data ();
// note that QuadComparator is a
// class declared and defined in
// this file
- std::map<internal::Triangulation::TriaObject<2>,
+ std::map<internal::TriangulationImplementation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
std::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
}
- internal::Triangulation::TriaObject<2>
+ internal::TriangulationImplementation::TriaObject<2>
quad(face_line_list[0],
face_line_list[1],
face_line_list[2],
// new one and instead
// later set the
// face_orientation flag
- const internal::Triangulation::TriaObject<2>
+ const internal::TriangulationImplementation::TriaObject<2>
test_quad_1(quad.face(2), quad.face(3),
quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
test_quad_2(quad.face(0), quad.face(1),
{
typename Triangulation<dim,spacedim>::raw_quad_iterator
quad = triangulation.begin_raw_quad();
- typename std::map<internal::Triangulation::TriaObject<2>,
+ typename std::map<internal::TriangulationImplementation::TriaObject<2>,
std::pair<typename Triangulation<dim,spacedim>::quad_iterator,
std::array<bool,GeometryInfo<dim>::lines_per_face> >,
QuadComparator>
face_line_list[l]=needed_lines[inverse_line_list[GeometryInfo<dim>::
face_to_cell_lines(face,l)]]->index();
- internal::Triangulation::TriaObject<2>
+ internal::TriangulationImplementation::TriaObject<2>
quad(face_line_list[0],
face_line_list[1],
face_line_list[2],
// then. construct all
// possibilities and check
// them one after the other
- const internal::Triangulation::TriaObject<2>
+ const internal::TriangulationImplementation::TriaObject<2>
test_quad_1(quad.face(2), quad.face(3),
quad.face(0), quad.face(1)),//face_orientation=false, face_flip=false, face_rotation=false
test_quad_2(quad.face(0), quad.face(1),
// make the cell out of
// these iterators
- cell->set (internal::Triangulation
+ cell->set (internal::TriangulationImplementation
::TriaObject<3> (face_iterator[0]->index(),
face_iterator[1]->index(),
face_iterator[2]->index(),
// and because boundary quad
// orientation does not carry
// any information.
- internal::Triangulation::TriaObject<2>
+ internal::TriangulationImplementation::TriaObject<2>
quad_compare_1(line[0]->index(), line[1]->index(),
line[2]->index(), line[3]->index());
- internal::Triangulation::TriaObject<2>
+ internal::TriangulationImplementation::TriaObject<2>
quad_compare_2(line[2]->index(), line[3]->index(),
line[0]->index(), line[1]->index());
const unsigned int switch_1_user_index=switch_1->user_index();
const bool switch_1_user_flag=switch_1->user_flag_set();
- switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
- switch_2->line_index(1),
- switch_2->line_index(2),
- switch_2->line_index(3)));
+ switch_1->set(internal::TriangulationImplementation::TriaObject<2>(switch_2->line_index(0),
+ switch_2->line_index(1),
+ switch_2->line_index(2),
+ switch_2->line_index(3)));
switch_1->set_line_orientation(0, switch_2->line_orientation(0));
switch_1->set_line_orientation(1, switch_2->line_orientation(1));
switch_1->set_line_orientation(2, switch_2->line_orientation(2));
else
switch_1->clear_user_flag();
- switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
- switch_1_lines[1],
- switch_1_lines[2],
- switch_1_lines[3]));
+ switch_2->set(internal::TriangulationImplementation::TriaObject<2>(switch_1_lines[0],
+ switch_1_lines[1],
+ switch_1_lines[2],
+ switch_1_lines[3]));
switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
new_lines[l]=cell->line(face_no)->child(c);
Assert(l==8, ExcInternalError());
- new_lines[8] ->set (internal::Triangulation::
+ new_lines[8] ->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[6], new_vertices[8]));
- new_lines[9] ->set (internal::Triangulation::
+ new_lines[9] ->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[8], new_vertices[7]));
- new_lines[10]->set (internal::Triangulation::
+ new_lines[10]->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[4], new_vertices[8]));
- new_lines[11]->set (internal::Triangulation::
+ new_lines[11]->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[8], new_vertices[5]));
}
else if (ref_case==RefinementCase<dim>::cut_x)
new_lines[3]=cell->line(2)->child(1);
new_lines[4]=cell->line(3)->child(0);
new_lines[5]=cell->line(3)->child(1);
- new_lines[6]->set (internal::Triangulation::
+ new_lines[6]->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[6], new_vertices[7]));
}
else
new_lines[3]=cell->line(1)->child(1);
new_lines[4]=cell->line(2);
new_lines[5]=cell->line(3);
- new_lines[6]->set (internal::Triangulation::
+ new_lines[6]->set (internal::TriangulationImplementation::
TriaObject<1>(new_vertices[4], new_vertices[5]));
}
// .-10.11-.
// 0 8 2
// .-4-.-5-.
- subcells[0]->set (internal::Triangulation::
+ subcells[0]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[0]->index(),
new_lines[8]->index(),
new_lines[4]->index(),
new_lines[10]->index()));
- subcells[1]->set (internal::Triangulation::
+ subcells[1]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[8]->index(),
new_lines[2]->index(),
new_lines[5]->index(),
new_lines[11]->index()));
- subcells[2]->set (internal::Triangulation::
+ subcells[2]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[1]->index(),
new_lines[9]->index(),
new_lines[10]->index(),
new_lines[6]->index()));
- subcells[3]->set (internal::Triangulation::
+ subcells[3]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[9]->index(),
new_lines[3]->index(),
new_lines[11]->index(),
// 0 6 1
// | | |
// .-2-.-3-.
- subcells[0]->set (internal::Triangulation::
+ subcells[0]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[0]->index(),
new_lines[6]->index(),
new_lines[2]->index(),
new_lines[4]->index()));
- subcells[1]->set (internal::Triangulation::
+ subcells[1]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[6]->index(),
new_lines[1]->index(),
new_lines[3]->index(),
// .---6---.
// 0 2
// .---4---.
- subcells[0]->set (internal::Triangulation::
+ subcells[0]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[0]->index(),
new_lines[2]->index(),
new_lines[4]->index(),
new_lines[6]->index()));
- subcells[1]->set (internal::Triangulation::
+ subcells[1]->set (internal::TriangulationImplementation::
TriaObject<2>(new_lines[1]->index(),
new_lines[3]->index(),
new_lines[6]->index(),
if (cell->refine_flag_set())
{
triangulation.levels
- .push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
+ .push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
}
// insert first child
cell->set_children (0, first_child->index());
first_child->clear_children ();
- first_child->set (internal::Triangulation
+ first_child->set (internal::TriangulationImplementation
::TriaObject<1> (cell->vertex_index(0),
next_unused_vertex));
first_child->set_material_id (cell->material_id());
first_child->face(1)->set_manifold_id(cell->manifold_id());
// reset neighborship info (refer to
- // internal::Triangulation::TriaLevel<0> for
+ // internal::TriangulationImplementation::TriaLevel<0> for
// details)
first_child->set_neighbor (1, second_child);
if (cell->neighbor(0).state() != IteratorState::valid)
// insert second child
second_child->clear_children ();
- second_child->set (internal::Triangulation
+ second_child->set (internal::TriangulationImplementation
::TriaObject<1>(next_unused_vertex,
cell->vertex_index(1)));
second_child->set_neighbor (0, first_child);
if (cell->used())
if (cell->refine_flag_set())
{
- triangulation.levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
+ triangulation.levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
}
Assert (children[0]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
Assert (children[1]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
- children[0]->set (internal::Triangulation
+ children[0]->set (internal::TriangulationImplementation
::TriaObject<1>(line->vertex_index(0),
next_unused_vertex));
- children[1]->set (internal::Triangulation
+ children[1]->set (internal::TriangulationImplementation
::TriaObject<1>(next_unused_vertex,
line->vertex_index(1)));
if (cell->used())
if (cell->refine_flag_set())
{
- triangulation.levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>());
+ triangulation.levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
}
Assert (children[0]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
Assert (children[1]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
- children[0]->set (internal::Triangulation
+ children[0]->set (internal::TriangulationImplementation
::TriaObject<1>(line->vertex_index(0),
next_unused_vertex));
- children[1]->set (internal::Triangulation
+ children[1]->set (internal::TriangulationImplementation
::TriaObject<1>(next_unused_vertex,
line->vertex_index(1)));
vertex_indices[1]=quad->line(1)->child(0)->vertex_index(1);
}
- new_line->set (internal::Triangulation::
+ new_line->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[0], vertex_indices[1]));
new_line->set_used_flag();
new_line->clear_user_flag();
if (aniso_quad_ref_case==RefinementCase<dim-1>::cut_x)
{
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(quad->line_index(0),
new_line->index(),
quad->line(2)->child(index[0][quad->line_orientation(2)])->index(),
quad->line(3)->child(index[0][quad->line_orientation(3)])->index()));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(new_line->index(),
quad->line_index(1),
quad->line(2)->child(index[1][quad->line_orientation(2)])->index(),
}
else
{
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(quad->line(0)->child(index[0][quad->line_orientation(0)])->index(),
quad->line(1)->child(index[0][quad->line_orientation(1)])->index(),
quad->line_index(2),
new_line->index()));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(quad->line(0)->child(index[1][quad->line_orientation(0)])->index(),
quad->line(1)->child(index[1][quad->line_orientation(1)])->index(),
new_line->index(),
{
Assert(!old_child[i]->has_children(), ExcInternalError());
- new_child[i]->set(internal::Triangulation::TriaObject<1>(old_child[i]->vertex_index(0),
- old_child[i]->vertex_index(1)));
+ new_child[i]->set(internal::TriangulationImplementation::TriaObject<1>(old_child[i]->vertex_index(0),
+ old_child[i]->vertex_index(1)));
new_child[i]->set_boundary_id_internal(old_child[i]->boundary_id());
new_child[i]->set_manifold_id(old_child[i]->manifold_id());
new_child[i]->set_user_index(old_child[i]->user_index());
const int switch_1_first_child_pair=(switch_1_refinement_case ? switch_1->child_index(0) : -1);
const int switch_1_second_child_pair=(switch_1_refinement_case==RefinementCase<dim-1>::cut_xy ? switch_1->child_index(2) : -1);
- switch_1->set(internal::Triangulation::TriaObject<2>(switch_2->line_index(0),
- switch_2->line_index(1),
- switch_2->line_index(2),
- switch_2->line_index(3)));
+ switch_1->set(internal::TriangulationImplementation::TriaObject<2>(switch_2->line_index(0),
+ switch_2->line_index(1),
+ switch_2->line_index(2),
+ switch_2->line_index(3)));
switch_1->set_line_orientation(0, switch_2->line_orientation(0));
switch_1->set_line_orientation(1, switch_2->line_orientation(1));
switch_1->set_line_orientation(2, switch_2->line_orientation(2));
if (switch_2->refinement_case()==RefinementCase<dim-1>::cut_xy)
switch_1->set_children(2, switch_2->child_index(2));
- switch_2->set(internal::Triangulation::TriaObject<2>(switch_1_lines[0],
- switch_1_lines[1],
- switch_1_lines[2],
- switch_1_lines[3]));
+ switch_2->set(internal::TriangulationImplementation::TriaObject<2>(switch_1_lines[0],
+ switch_1_lines[1],
+ switch_1_lines[2],
+ switch_1_lines[3]));
switch_2->set_line_orientation(0, switch_1_line_orientations[0]);
switch_2->set_line_orientation(1, switch_1_line_orientations[1]);
switch_2->set_line_orientation(2, switch_1_line_orientations[2]);
Assert (children[0]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
Assert (children[1]->used() == false, ExcMessage("Internal error: We want to use a cell during refinement that should be unused, but turns out not to be."));
- children[0]->set (internal::Triangulation::
+ children[0]->set (internal::TriangulationImplementation::
TriaObject<1>(middle_line->vertex_index(0),
next_unused_vertex));
- children[1]->set (internal::Triangulation::
+ children[1]->set (internal::TriangulationImplementation::
TriaObject<1>(next_unused_vertex,
middle_line->vertex_index(1)));
next_unused_vertex
};
- new_lines[0]->set (internal::Triangulation::
+ new_lines[0]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[2], vertex_indices[4]));
- new_lines[1]->set (internal::Triangulation::
+ new_lines[1]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[4], vertex_indices[3]));
- new_lines[2]->set (internal::Triangulation::
+ new_lines[2]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[0], vertex_indices[4]));
- new_lines[3]->set (internal::Triangulation::
+ new_lines[3]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[4], vertex_indices[1]));
for (unsigned int i=0; i<4; ++i)
// note these quads as children to the present one
quad->set_children (0, new_quads[0]->index());
quad->set_children (2, new_quads[2]->index());
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[0],
line_indices[8],
line_indices[4],
quad->set_refinement_case(RefinementCase<2>::cut_xy);
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[0],
line_indices[8],
line_indices[4],
line_indices[10]));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[8],
line_indices[2],
line_indices[5],
line_indices[11]));
- new_quads[2]->set (internal::Triangulation
+ new_quads[2]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[1],
line_indices[9],
line_indices[10],
line_indices[6]));
- new_quads[3]->set (internal::Triangulation
+ new_quads[3]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[9],
line_indices[3],
line_indices[11],
// set up the new quad, line numbering is as
// indicated above
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[0],
line_indices[1],
line_indices[2],
};
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[1],
quad_indices[0],
quad_indices[3],
quad_indices[5],
quad_indices[7],
quad_indices[9]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[0],
quad_indices[2],
quad_indices[4],
// set up the new quad, line numbering is as
// indicated above
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[2],
line_indices[3],
line_indices[0],
};
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[1],
quad_indices[3],
quad_indices[5],
quad_indices[0],
quad_indices[7],
quad_indices[9]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[2],
quad_indices[4],
quad_indices[0],
// set up the new quad, line numbering is as
// indicated above
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[0],
line_indices[1],
line_indices[2],
hex->face(5)->index() //10
};
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[1],
quad_indices[3],
quad_indices[5],
quad_indices[7],
quad_indices[9],
quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[2],
quad_indices[4],
quad_indices[6],
//
// first, create the new internal line
- new_lines[0]->set (internal::Triangulation::
+ new_lines[0]->set (internal::TriangulationImplementation::
TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(4)),
middle_vertex_index<dim,spacedim>(hex->face(5))));
// | | | | | |
// *---*---*y *-6-*-7-*
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[2],
line_indices[12],
line_indices[4],
line_indices[8]));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[12],
line_indices[3],
line_indices[5],
line_indices[9]));
- new_quads[2]->set (internal::Triangulation
+ new_quads[2]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[6],
line_indices[10],
line_indices[0],
line_indices[12]));
- new_quads[3]->set (internal::Triangulation
+ new_quads[3]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[7],
line_indices[11],
line_indices[12],
hex->face(5)->isotropic_child_index(GeometryInfo<dim>::standard_to_real_face_vertex(3,f_or[5],f_fl[5],f_ro[5]))
};
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[4],
quad_indices[0],
quad_indices[8],
quad_indices[2],
quad_indices[12],
quad_indices[16]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[0],
quad_indices[6],
quad_indices[9],
quad_indices[3],
quad_indices[13],
quad_indices[17]));
- new_hexes[2]->set (internal::Triangulation
+ new_hexes[2]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[5],
quad_indices[1],
quad_indices[2],
quad_indices[10],
quad_indices[14],
quad_indices[18]));
- new_hexes[3]->set (internal::Triangulation
+ new_hexes[3]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[1],
quad_indices[7],
quad_indices[3],
//
// first, create the new internal line
- new_lines[0]->set (internal::Triangulation::
+ new_lines[0]->set (internal::TriangulationImplementation::
TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(2)),
middle_vertex_index<dim,spacedim>(hex->face(3))));
// / / / / / /
// *----*----*x *--6-*--7-*
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[0],
line_indices[12],
line_indices[6],
line_indices[10]));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[12],
line_indices[1],
line_indices[7],
line_indices[11]));
- new_quads[2]->set (internal::Triangulation
+ new_quads[2]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[4],
line_indices[8],
line_indices[2],
line_indices[12]));
- new_quads[3]->set (internal::Triangulation
+ new_quads[3]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[5],
line_indices[9],
line_indices[12],
// *---*---*
// | 0 | 2 |
// *---*---*
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[4],
quad_indices[2],
quad_indices[8],
quad_indices[12],
quad_indices[16],
quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[5],
quad_indices[3],
quad_indices[9],
quad_indices[13],
quad_indices[0],
quad_indices[18]));
- new_hexes[2]->set (internal::Triangulation
+ new_hexes[2]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[2],
quad_indices[6],
quad_indices[10],
quad_indices[14],
quad_indices[17],
quad_indices[1]));
- new_hexes[3]->set (internal::Triangulation
+ new_hexes[3]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[3],
quad_indices[7],
quad_indices[11],
// first, create the new
// internal line
- new_lines[0]->set (internal::Triangulation::
+ new_lines[0]->set (internal::TriangulationImplementation::
TriaObject<1>(middle_vertex_index<dim,spacedim>(hex->face(0)),
middle_vertex_index<dim,spacedim>(hex->face(1))));
// / 0 / 6 10
// *---------*x *----0----*
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[6],
line_indices[10],
line_indices[0],
line_indices[12]));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[7],
line_indices[11],
line_indices[12],
line_indices[1]));
- new_quads[2]->set (internal::Triangulation
+ new_quads[2]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[2],
line_indices[12],
line_indices[4],
line_indices[8]));
- new_quads[3]->set (internal::Triangulation
+ new_quads[3]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[12],
line_indices[3],
line_indices[5],
hex->face(5)->child_index(1-child_at_origin[hex->face(5)->refinement_case()-1][f_fl[5]][f_ro[5]])
};
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[4],
quad_indices[8],
quad_indices[12],
quad_indices[2],
quad_indices[16],
quad_indices[0]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[5],
quad_indices[9],
quad_indices[2],
quad_indices[14],
quad_indices[17],
quad_indices[1]));
- new_hexes[2]->set (internal::Triangulation
+ new_hexes[2]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[6],
quad_indices[10],
quad_indices[13],
quad_indices[3],
quad_indices[0],
quad_indices[18]));
- new_hexes[3]->set (internal::Triangulation
+ new_hexes[3]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[7],
quad_indices[11],
quad_indices[3],
next_unused_vertex
};
- new_lines[0]->set (internal::Triangulation::
+ new_lines[0]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[2], vertex_indices[6]));
- new_lines[1]->set (internal::Triangulation::
+ new_lines[1]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[6], vertex_indices[3]));
- new_lines[2]->set (internal::Triangulation::
+ new_lines[2]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[0], vertex_indices[6]));
- new_lines[3]->set (internal::Triangulation::
+ new_lines[3]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[6], vertex_indices[1]));
- new_lines[4]->set (internal::Triangulation::
+ new_lines[4]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[4], vertex_indices[6]));
- new_lines[5]->set (internal::Triangulation::
+ new_lines[5]->set (internal::TriangulationImplementation::
TriaObject<1>(vertex_indices[6], vertex_indices[5]));
// again, first collect some data about the
// / 8 / 9 / 2 24 6
// *----*----*x *--8-*--9-*
- new_quads[0]->set (internal::Triangulation
+ new_quads[0]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[10],
line_indices[28],
line_indices[16],
line_indices[24]));
- new_quads[1]->set (internal::Triangulation
+ new_quads[1]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[28],
line_indices[14],
line_indices[17],
line_indices[25]));
- new_quads[2]->set (internal::Triangulation
+ new_quads[2]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[11],
line_indices[29],
line_indices[24],
line_indices[20]));
- new_quads[3]->set (internal::Triangulation
+ new_quads[3]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[29],
line_indices[15],
line_indices[25],
line_indices[21]));
- new_quads[4]->set (internal::Triangulation
+ new_quads[4]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[18],
line_indices[26],
line_indices[0],
line_indices[28]));
- new_quads[5]->set (internal::Triangulation
+ new_quads[5]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[26],
line_indices[22],
line_indices[1],
line_indices[29]));
- new_quads[6]->set (internal::Triangulation
+ new_quads[6]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[19],
line_indices[27],
line_indices[28],
line_indices[4]));
- new_quads[7]->set (internal::Triangulation
+ new_quads[7]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[27],
line_indices[23],
line_indices[29],
line_indices[5]));
- new_quads[8]->set (internal::Triangulation
+ new_quads[8]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[2],
line_indices[24],
line_indices[8],
line_indices[26]));
- new_quads[9]->set (internal::Triangulation
+ new_quads[9]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[24],
line_indices[6],
line_indices[9],
line_indices[27]));
- new_quads[10]->set (internal::Triangulation
+ new_quads[10]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[3],
line_indices[25],
line_indices[26],
line_indices[12]));
- new_quads[11]->set (internal::Triangulation
+ new_quads[11]->set (internal::TriangulationImplementation
::TriaObject<2>(line_indices[25],
line_indices[7],
line_indices[27],
};
// bottom children
- new_hexes[0]->set (internal::Triangulation
+ new_hexes[0]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[12],
quad_indices[0],
quad_indices[20],
quad_indices[4],
quad_indices[28],
quad_indices[8]));
- new_hexes[1]->set (internal::Triangulation
+ new_hexes[1]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[0],
quad_indices[16],
quad_indices[22],
quad_indices[6],
quad_indices[29],
quad_indices[9]));
- new_hexes[2]->set (internal::Triangulation
+ new_hexes[2]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[13],
quad_indices[1],
quad_indices[4],
quad_indices[24],
quad_indices[30],
quad_indices[10]));
- new_hexes[3]->set (internal::Triangulation
+ new_hexes[3]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[1],
quad_indices[17],
quad_indices[6],
quad_indices[11]));
// top children
- new_hexes[4]->set (internal::Triangulation
+ new_hexes[4]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[14],
quad_indices[2],
quad_indices[21],
quad_indices[5],
quad_indices[8],
quad_indices[32]));
- new_hexes[5]->set (internal::Triangulation
+ new_hexes[5]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[2],
quad_indices[18],
quad_indices[23],
quad_indices[7],
quad_indices[9],
quad_indices[33]));
- new_hexes[6]->set (internal::Triangulation
+ new_hexes[6]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[15],
quad_indices[3],
quad_indices[5],
quad_indices[25],
quad_indices[10],
quad_indices[34]));
- new_hexes[7]->set (internal::Triangulation
+ new_hexes[7]->set (internal::TriangulationImplementation
::TriaObject<3>(quad_indices[3],
quad_indices[19],
quad_indices[7],
vertex_to_boundary_id_map_1d(std::move(tria.vertex_to_boundary_id_map_1d)),
vertex_to_manifold_id_map_1d(std::move(tria.vertex_to_manifold_id_map_1d))
{
- tria.number_cache = internal::Triangulation::NumberCache<dim>();
+ tria.number_cache = internal::TriangulationImplementation::NumberCache<dim>();
}
vertex_to_boundary_id_map_1d = std::move(tria.vertex_to_boundary_id_map_1d);
vertex_to_manifold_id_map_1d = std::move(tria.vertex_to_manifold_id_map_1d);
- tria.number_cache = internal::Triangulation::NumberCache<dim>();
+ tria.number_cache = internal::TriangulationImplementation::NumberCache<dim>();
return *this;
}
// if we have not found an entry connected with number, we return
// the default (flat) manifold
- return internal::Triangulation::get_default_flat_manifold<dim,spacedim>();
+ return internal::TriangulationImplementation::get_default_flat_manifold<dim,spacedim>();
}
smooth_grid = other_tria.smooth_grid;
if (dim > 1)
- faces = std_cxx14::make_unique<internal::Triangulation::TriaFaces<dim>> (*other_tria.faces);
+ faces = std_cxx14::make_unique<internal::TriangulationImplementation::TriaFaces<dim>> (*other_tria.faces);
typename std::map<types::manifold_id,
SmartPointer<const Manifold<dim,spacedim>, Triangulation<dim, spacedim> > >::const_iterator
levels.reserve (other_tria.levels.size());
for (unsigned int level=0; level<other_tria.levels.size(); ++level)
- levels.push_back (std_cxx14::make_unique<internal::Triangulation::TriaLevel<dim>>
+ levels.push_back (std_cxx14::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>
(*other_tria.levels[level]));
number_cache = other_tria.number_cache;
// because sometimes other objects are already attached to it:
try
{
- internal::Triangulation::Implementation::create_triangulation (v, cells, subcelldata, *this);
+ internal::TriangulationImplementation::Implementation::create_triangulation (v, cells, subcelldata, *this);
}
catch (...)
{
// update our counts of the various elements of a triangulation, and set
// active_cell_indices of all cells
- internal::Triangulation::Implementation
+ internal::TriangulationImplementation::Implementation
::compute_number_cache (*this, levels.size(), number_cache);
reset_active_cell_indices ();
{
// clear user data of cells
template <int dim>
- void clear_user_data (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<dim>>> &levels)
+ void clear_user_data (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<dim>>> &levels)
{
for (unsigned int level=0; level<levels.size(); ++level)
levels[level]->cells.clear_user_data();
// clear user data of faces
- void clear_user_data (internal::Triangulation::TriaFaces<1> *)
+ void clear_user_data (internal::TriangulationImplementation::TriaFaces<1> *)
{
// nothing to do in 1d
}
- void clear_user_data (internal::Triangulation::TriaFaces<2> *faces)
+ void clear_user_data (internal::TriangulationImplementation::TriaFaces<2> *faces)
{
faces->lines.clear_user_data();
}
- void clear_user_data (internal::Triangulation::TriaFaces<3> *faces)
+ void clear_user_data (internal::TriangulationImplementation::TriaFaces<3> *faces)
{
faces->lines.clear_user_data();
faces->quads.clear_user_data();
namespace
{
- void clear_user_flags_line (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<1>>> &levels,
- internal::Triangulation::TriaFaces<1> *)
+ void clear_user_flags_line (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<1>>> &levels,
+ internal::TriangulationImplementation::TriaFaces<1> *)
{
for (unsigned int level=0; level<levels.size(); ++level)
levels[level]->cells.clear_user_flags();
}
template <int dim>
- void clear_user_flags_line (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<dim>>> &,
- internal::Triangulation::TriaFaces<dim> *faces)
+ void clear_user_flags_line (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<dim>>> &,
+ internal::TriangulationImplementation::TriaFaces<dim> *faces)
{
faces->lines.clear_user_flags();
}
namespace
{
- void clear_user_flags_quad (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<1>>> &,
- internal::Triangulation::TriaFaces<1> *)
+ void clear_user_flags_quad (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<1>>> &,
+ internal::TriangulationImplementation::TriaFaces<1> *)
{
// nothing to do in 1d
}
- void clear_user_flags_quad (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<2>>> &levels,
- internal::Triangulation::TriaFaces<2> *)
+ void clear_user_flags_quad (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<2>>> &levels,
+ internal::TriangulationImplementation::TriaFaces<2> *)
{
for (unsigned int level=0; level<levels.size(); ++level)
levels[level]->cells.clear_user_flags();
}
template <int dim>
- void clear_user_flags_quad (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<dim>>> &,
- internal::Triangulation::TriaFaces<dim> *faces)
+ void clear_user_flags_quad (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<dim>>> &,
+ internal::TriangulationImplementation::TriaFaces<dim> *faces)
{
faces->quads.clear_user_flags();
}
namespace
{
- void clear_user_flags_hex (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<1>>> &,
- internal::Triangulation::TriaFaces<1> *)
+ void clear_user_flags_hex (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<1>>> &,
+ internal::TriangulationImplementation::TriaFaces<1> *)
{
// nothing to do in 1d
}
- void clear_user_flags_hex (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<2>>> &,
- internal::Triangulation::TriaFaces<2> *)
+ void clear_user_flags_hex (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<2>>> &,
+ internal::TriangulationImplementation::TriaFaces<2> *)
{
// nothing to do in 2d
}
- void clear_user_flags_hex (std::vector<std::unique_ptr<internal::Triangulation::TriaLevel<3>>> &levels,
- internal::Triangulation::TriaFaces<3> *)
+ void clear_user_flags_hex (std::vector<std::unique_ptr<internal::TriangulationImplementation::TriaLevel<3>>> &levels,
+ internal::TriangulationImplementation::TriaFaces<3> *)
{
for (unsigned int level=0; level<levels.size(); ++level)
levels[level]->cells.clear_user_flags();
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
inline
unsigned int
- n_cells (const internal::Triangulation::NumberCache<1> &c)
+ n_cells (const internal::TriangulationImplementation::NumberCache<1> &c)
{
return c.n_lines;
}
inline
unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<1> &c)
+ n_active_cells (const internal::TriangulationImplementation::NumberCache<1> &c)
{
return c.n_active_lines;
}
inline
unsigned int
- n_cells (const internal::Triangulation::NumberCache<2> &c)
+ n_cells (const internal::TriangulationImplementation::NumberCache<2> &c)
{
return c.n_quads;
}
inline
unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<2> &c)
+ n_active_cells (const internal::TriangulationImplementation::NumberCache<2> &c)
{
return c.n_active_quads;
}
inline
unsigned int
- n_cells (const internal::Triangulation::NumberCache<3> &c)
+ n_cells (const internal::TriangulationImplementation::NumberCache<3> &c)
{
return c.n_hexes;
}
inline
unsigned int
- n_active_cells (const internal::Triangulation::NumberCache<3> &c)
+ n_active_cells (const internal::TriangulationImplementation::NumberCache<3> &c)
{
return c.n_active_hexes;
}
template <int dim, int spacedim>
unsigned int Triangulation<dim, spacedim>::n_cells () const
{
- return internal::Triangulation::n_cells (number_cache);
+ return internal::TriangulationImplementation::n_cells (number_cache);
}
template <int dim, int spacedim>
unsigned int Triangulation<dim, spacedim>::n_active_cells () const
{
- return internal::Triangulation::n_active_cells (number_cache);
+ return internal::TriangulationImplementation::n_active_cells (number_cache);
}
template <int dim, int spacedim>
manifold.clear();
- number_cache = internal::Triangulation::NumberCache<dim>();
+ number_cache = internal::TriangulationImplementation::NumberCache<dim>();
}
const DistortedCellList
cells_with_distorted_children
=
- internal::Triangulation::Implementation::
+ internal::TriangulationImplementation::Implementation::
execute_refinement (*this, check_for_distorted_cells);
// re-compute number of lines
- internal::Triangulation::Implementation
+ internal::TriangulationImplementation::Implementation
::compute_number_cache (*this, levels.size(), number_cache);
#ifdef DEBUG
// inform all listeners that cell coarsening is going to happen
signals.pre_coarsening_on_cell(cell);
// use a separate function, since this is dimension specific
- internal::Triangulation::Implementation
+ internal::TriangulationImplementation::Implementation
::delete_children (*this, cell, line_cell_count, quad_cell_count);
}
// re-compute number of lines and quads
- internal::Triangulation::Implementation
+ internal::TriangulationImplementation::Implementation
::compute_number_cache (*this, levels.size(), number_cache);
// in principle no user flags should be set any more at this point
if (cell->user_flag_set())
// if allowed: flag the
// children for coarsening
- if (internal::Triangulation::Implementation::template coarsening_allowed<dim,spacedim>(cell))
+ if (internal::TriangulationImplementation::Implementation::template coarsening_allowed<dim,spacedim>(cell))
for (unsigned int c=0; c<cell->n_children(); ++c)
{
Assert (cell->child(c)->refine_flag_set()==false,
// volume or at least with a part, that is negative, if the
// cell is refined anisotropically. we have to check, whether
// that can happen
- internal::Triangulation::Implementation::prevent_distorted_boundary_cells(*this);
+ internal::TriangulationImplementation::Implementation::prevent_distorted_boundary_cells(*this);
/////////////////////////////////
// STEP 6:
// take care that no double refinement
// is done at each line in 3d or higher
// dimensions.
- internal::Triangulation::Implementation::prepare_refinement_dim_dependent (*this);
+ internal::TriangulationImplementation::Implementation::prepare_refinement_dim_dependent (*this);
//////////////////////////////////////
// STEP 8:
template <int structdim, int dim, int spacedim>
void
TriaAccessor<structdim, dim, spacedim>::
-set (const internal::Triangulation::TriaObject<structdim> &object) const
+set (const internal::TriangulationImplementation::TriaObject<structdim> &object) const
{
this->objects().cells[this->present_index] = object;
}
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
std::size_t
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <int dim>
void
}
-template class internal::Triangulation::TriaLevel<1>;
-template class internal::Triangulation::TriaLevel<2>;
+template class internal::TriangulationImplementation::TriaLevel<1>;
+template class internal::TriangulationImplementation::TriaLevel<2>;
DEAL_II_NAMESPACE_CLOSE
namespace internal
{
- namespace Triangulation
+ namespace TriangulationImplementation
{
template <class G>
void
{
namespace hp
{
- namespace DoFHandler
+ namespace DoFHandlerImplementation
{
// access class dealii::hp::DoFHandler instead of namespace
// internal::hp::DoFHandler, etc
{
// decide whether we need a sequential or a parallel shared/distributed policy
if (dynamic_cast<const parallel::shared::Triangulation< dim, spacedim>*> (&*this->tria) != nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelShared<DoFHandler<dim,spacedim> >> (*this);
else if (dynamic_cast<const parallel::distributed::Triangulation< dim, spacedim >*> (&*this->tria) != nullptr)
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::ParallelDistributed<DoFHandler<dim,spacedim> >> (*this);
else
- policy = std_cxx14::make_unique<internal::DoFHandler::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
+ policy = std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<DoFHandler<dim,spacedim> >> (*this);
create_active_fe_table ();
// at the beginning, make sure every processor knows the
// active_fe_indices on both its own cells and all ghost cells
- dealii::internal::hp::DoFHandler::Implementation::communicate_active_fe_indices (*this);
+ dealii::internal::hp::DoFHandlerImplementation::Implementation::communicate_active_fe_indices (*this);
// If an underlying shared::Tria allows artificial cells,
// then save the current set of subdomain ids, and set
// then allocate space for all the other tables
- dealii::internal::hp::DoFHandler::Implementation::reserve_space (*this);
+ dealii::internal::hp::DoFHandlerImplementation::Implementation::reserve_space (*this);
// now undo the subdomain modification
DoFHandler<dim, spacedim>::max_couplings_between_dofs () const
{
Assert (finite_elements != nullptr, ExcNoFESelected());
- return dealii::internal::hp::DoFHandler::Implementation::max_couplings_between_dofs (*this);
+ return dealii::internal::hp::DoFHandlerImplementation::Implementation::max_couplings_between_dofs (*this);
}
namespace internal
{
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
template <typename VectorType>
inline
(void)src;
(void)dst;
- internal::SparseMatrix::check_vector_map_equality(*matrix, src, dst);
+ internal::SparseMatrixImplementation::check_vector_map_equality(*matrix, src, dst);
const size_type dst_local_size = internal::end(dst) - internal::begin(dst);
AssertDimension (dst_local_size, static_cast<size_type>(matrix->RangeMap().NumMyPoints()));
const size_type src_local_size = internal::end(src) - internal::begin(src);
Assert (&src != &dst, ExcSourceEqualsDestination());
Assert (matrix->Filled(), ExcMatrixNotCompressed());
- internal::SparseMatrix::check_vector_map_equality(*matrix, dst, src);
+ internal::SparseMatrixImplementation::check_vector_map_equality(*matrix, dst, src);
const size_type dst_local_size = internal::end(dst) - internal::begin(dst);
AssertDimension (dst_local_size, static_cast<size_type>(matrix->DomainMap().NumMyPoints()));
const size_type src_local_size = internal::end(src) - internal::begin(src);
#endif
}
- namespace LinearOperator
+ namespace LinearOperatorImplementation
{
TrilinosPayload::TrilinosPayload ()
namespace internal
{
- namespace GrowingVectorMemory
+ namespace GrowingVectorMemoryImplementation
{
void release_all_unused_memory()
{
namespace internal
{
- namespace DataOut
+ namespace DataOutImplementation
{
template <int dim, int spacedim>
ParallelData<dim,spacedim>::
DataOut<dim,DoFHandlerType>::
build_one_patch
(const std::pair<cell_iterator, unsigned int> *cell_and_index,
- internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &scratch_data,
+ internal::DataOutImplementation::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &scratch_data,
const unsigned int n_subdivisions,
const CurvedCellRegion curved_cell_region)
{
// gradient etc.
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_scalar.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_scalar.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_scalar.solution_hessians);
if (update_flags & update_quadrature_points)
// derivative...
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_system.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_system.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_system.solution_hessians);
if (update_flags & update_quadrature_points)
{
// first output the real part of the solution vector
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_scalar.solution_values);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(offset,q) = scratch_data.patch_values_scalar.solution_values[q];
if (this->dof_data[dataset]->is_complex_valued() == true)
{
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::imaginary_part,
+ internal::DataOutImplementation::ComponentExtractor::imaginary_part,
scratch_data.patch_values_scalar.solution_values);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(offset+1,q) = scratch_data.patch_values_scalar.solution_values[q];
// same as above: first the real part
const unsigned int stride = (this->dof_data[dataset]->is_complex_valued() ? 2 : 1);
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
scratch_data.patch_values_system.solution_values);
for (unsigned int component=0; component<n_components;
++component)
if (this->dof_data[dataset]->is_complex_valued() == true)
{
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::imaginary_part,
+ internal::DataOutImplementation::ComponentExtractor::imaginary_part,
scratch_data.patch_values_system.solution_values);
for (unsigned int component=0; component<n_components;
++component)
{
const double value
= this->cell_data[dataset]->get_cell_data_value (cell_and_index->second,
- internal::DataOut::ComponentExtractor::real_part);
+ internal::DataOutImplementation::ComponentExtractor::real_part);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(offset,q) = value;
}
{
const double value
= this->cell_data[dataset]->get_cell_data_value (cell_and_index->second,
- internal::DataOut::ComponentExtractor::imaginary_part);
+ internal::DataOutImplementation::ComponentExtractor::imaginary_part);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(offset+1,q) = value;
}
Assert (dim==DoFHandlerType::dimension, ExcDimensionMismatch(dim, DoFHandlerType::dimension));
Assert (this->triangulation != nullptr,
- Exceptions::DataOut::ExcNoTriangulationSelected());
+ Exceptions::DataOutImplementation::ExcNoTriangulationSelected());
const unsigned int n_subdivisions = (n_subdivisions_ != 0)
? n_subdivisions_
: this->default_subdivisions;
Assert (n_subdivisions >= 1,
- Exceptions::DataOut::ExcInvalidNumberOfSubdivisions(n_subdivisions));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions(n_subdivisions));
this->validate_dataset_names();
ExcMessage("The update of normal vectors may not be requested for evaluation of "
"data on cells via DataPostprocessor."));
- internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
+ internal::DataOutImplementation::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
thread_data (n_datasets, n_subdivisions,
n_postprocessor_outputs,
mapping,
for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
{
namespace internal \{
- namespace DataOut \{
+ namespace DataOutImplementation \{
#if deal_II_dimension <= deal_II_space_dimension
template struct ParallelData<deal_II_dimension,deal_II_space_dimension>;
#endif
for (deal_II_dimension : DIMENSIONS)
{
namespace internal \{
- namespace DataOut \{
+ namespace DataOutImplementation \{
template struct ParallelDataBase<deal_II_dimension,deal_II_dimension>;
\}
\}
for (DH : DOFHANDLER_TEMPLATES; deal_II_dimension : DIMENSIONS)
{
namespace internal \{
- namespace DataOut \{
+ namespace DataOutImplementation \{
template
void
ParallelDataBase<deal_II_dimension,deal_II_dimension>::
for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
{
namespace internal \{
- namespace DataOut \{
+ namespace DataOutImplementation \{
#if deal_II_dimension < deal_II_space_dimension
template struct ParallelDataBase<deal_II_dimension,deal_II_space_dimension>;
#endif
for (DH : DOFHANDLER_TEMPLATES; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
{
namespace internal \{
- namespace DataOut \{
+ namespace DataOutImplementation \{
#if deal_II_dimension < deal_II_space_dimension
template
void
namespace internal
{
- namespace DataOutFaces
+ namespace DataOutFacesImplementation
{
template <int dim, int spacedim>
ParallelData<dim,spacedim>::
const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags)
:
- internal::DataOut::
+ internal::DataOutImplementation::
ParallelDataBase<dim,spacedim> (n_datasets,
n_subdivisions,
n_postprocessor_outputs,
void
DataOutFaces<dim,DoFHandlerType>::
build_one_patch (const FaceDescriptor *cell_and_face,
- internal::DataOutFaces::ParallelData<dimension, dimension> &data,
+ internal::DataOutFacesImplementation::ParallelData<dimension, dimension> &data,
DataOutBase::Patch<dimension-1,space_dimension> &patch)
{
Assert (cell_and_face->first->is_locally_owned(),
// gradient etc.
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_hessians);
if (update_flags & update_quadrature_points)
data.resize_system_vectors(n_components);
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_hessians);
if (update_flags & update_quadrature_points)
if (n_components == 1)
{
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_values);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(offset,q) = data.patch_values_scalar.solution_values[q];
{
data.resize_system_vectors(n_components);
this->dof_data[dataset]->get_function_values (this_fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_values);
for (unsigned int component=0; component<n_components;
++component)
const double value
= this->cell_data[dataset]->get_cell_data_value (cell_number,
- internal::DataOut::ComponentExtractor::real_part);
+ internal::DataOutImplementation::ComponentExtractor::real_part);
for (unsigned int q=0; q<n_q_points; ++q)
patch.data(dataset+offset,q) = value;
}
: this->default_subdivisions;
Assert (n_subdivisions >= 1,
- Exceptions::DataOut::ExcInvalidNumberOfSubdivisions(n_subdivisions));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions(n_subdivisions));
Assert (this->triangulation != nullptr,
- Exceptions::DataOut::ExcNoTriangulationSelected());
+ Exceptions::DataOutImplementation::ExcNoTriangulationSelected());
this->validate_dataset_names();
update_flags |= this->dof_data[i]->postprocessor->get_needed_update_flags();
update_flags |= update_quadrature_points;
- internal::DataOutFaces::ParallelData<dimension, space_dimension>
+ internal::DataOutFacesImplementation::ParallelData<dimension, space_dimension>
thread_data (n_datasets,
n_subdivisions,
n_postprocessor_outputs,
&all_faces[0]+all_faces.size(),
std::bind(&DataOutFaces<dim,DoFHandlerType>::build_one_patch,
this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
- std::bind(&internal::DataOutFaces::
+ std::bind(&internal::DataOutFacesImplementation::
append_patch_to_list<dim,space_dimension>,
std::placeholders::_1, std::ref(this->patches)),
thread_data,
namespace internal
{
- namespace DataOutRotation
+ namespace DataOutRotationImplementation
{
template <int dim, int spacedim>
ParallelData<dim,spacedim>::
const std::vector<std::shared_ptr<dealii::hp::FECollection<dim,spacedim> > > &finite_elements,
const UpdateFlags update_flags)
:
- internal::DataOut::
+ internal::DataOutImplementation::
ParallelDataBase<dim,spacedim> (n_datasets,
n_subdivisions,
n_postprocessor_outputs,
void
DataOutRotation<dim,DoFHandlerType>::
build_one_patch (const cell_iterator *cell,
- internal::DataOutRotation::ParallelData<dimension, space_dimension> &data,
+ internal::DataOutRotationImplementation::ParallelData<dimension, space_dimension> &data,
std::vector<DataOutBase::Patch<dimension+1,space_dimension+1> > &my_patches)
{
if (dim == 3)
// value, gradient etc.
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_hessians);
if (update_flags & update_quadrature_points)
// its derivative...
if (update_flags & update_values)
this->dof_data[dataset]->get_function_values (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_values);
if (update_flags & update_gradients)
this->dof_data[dataset]->get_function_gradients (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_gradients);
if (update_flags & update_hessians)
this->dof_data[dataset]->get_function_hessians (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_hessians);
if (update_flags & update_quadrature_points)
else if (n_components == 1)
{
this->dof_data[dataset]->get_function_values (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_scalar.solution_values);
switch (dimension)
{
data.resize_system_vectors(n_components);
this->dof_data[dataset]->get_function_values (fe_patch_values,
- internal::DataOut::ComponentExtractor::real_part,
+ internal::DataOutImplementation::ComponentExtractor::real_part,
data.patch_values_system.solution_values);
for (unsigned int component=0; component<n_components;
typename Triangulation<dimension,space_dimension>::active_cell_iterator(*cell));
const double value
= this->cell_data[dataset]->get_cell_data_value (cell_number,
- internal::DataOut::ComponentExtractor::real_part);
+ internal::DataOutImplementation::ComponentExtractor::real_part);
switch (dimension)
{
case 1:
// template parameter
Assert (dim==dimension, ExcDimensionMismatch(dim, dimension));
Assert (this->triangulation != nullptr,
- Exceptions::DataOut::ExcNoTriangulationSelected());
+ Exceptions::DataOutImplementation::ExcNoTriangulationSelected());
const unsigned int n_subdivisions = (nnnn_subdivisions != 0)
? nnnn_subdivisions
: this->default_subdivisions;
Assert (n_subdivisions >= 1,
- Exceptions::DataOut::ExcInvalidNumberOfSubdivisions(n_subdivisions));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions(n_subdivisions));
this->validate_dataset_names();
else
n_postprocessor_outputs[dataset] = 0;
- internal::DataOutRotation::ParallelData<dimension, space_dimension>
+ internal::DataOutRotationImplementation::ParallelData<dimension, space_dimension>
thread_data (n_datasets,
n_subdivisions, n_patches_per_circle,
n_postprocessor_outputs,
&all_cells[0]+all_cells.size(),
std::bind(&DataOutRotation<dim,DoFHandlerType>::build_one_patch,
this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
- std::bind(&internal::DataOutRotation
+ std::bind(&internal::DataOutRotationImplementation
::append_patch_to_list<dim,space_dimension>,
std::placeholders::_1, std::ref(this->patches)),
thread_data,
const std::vector<std::string> &names)
{
Assert (dof_handler != nullptr,
- Exceptions::DataOut::ExcNoDoFHandlerSelected ());
+ Exceptions::DataOutImplementation::ExcNoDoFHandlerSelected ());
// either cell data and one name,
// or dof data and n_components names
Assert (((vec.size() == dof_handler->get_triangulation().n_active_cells()) &&
||
((vec.size() == dof_handler->n_dofs()) &&
(names.size() == dof_handler->get_fe(0).n_components())),
- Exceptions::DataOut::ExcInvalidNumberOfNames (names.size(),
- dof_handler->get_fe(0).n_components()));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfNames (names.size(),
+ dof_handler->get_fe(0).n_components()));
for (unsigned int i=0; i<names.size(); ++i)
Assert (names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789_<>()") == std::string::npos,
- Exceptions::DataOut::ExcInvalidCharacter (names[i],
- names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789_<>()")));
+ Exceptions::DataOutImplementation::ExcInvalidCharacter (names[i],
+ names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "0123456789_<>()")));
if (vec.size() == dof_handler->n_dofs())
{
: this->default_subdivisions;
Assert (n_subdivisions >= 1,
- Exceptions::DataOut::ExcInvalidNumberOfSubdivisions(n_subdivisions));
+ Exceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions(n_subdivisions));
Assert (dof_handler != nullptr,
- Exceptions::DataOut::ExcNoDoFHandlerSelected());
+ Exceptions::DataOutImplementation::ExcNoDoFHandlerSelected());
this->validate_dataset_names();
namespace internal
{
- namespace PointValueHistory
+ namespace PointValueHistoryImplementation
{
/// Only a constructor needed for this class (a struct really)
template <int dim>
.push_back (local_dof_indices[current_fe_index [component]]);
}
- internal::PointValueHistory::PointGeometryData<dim>
+ internal::PointValueHistoryImplementation::PointGeometryData<dim>
new_point_geometry_data (location, current_points, new_solution_indices);
point_geometry_data.push_back (new_point_geometry_data);
new_solution_indices.push_back (local_dof_indices[current_fe_index[point][component]]);
}
- internal::PointValueHistory::PointGeometryData<dim> new_point_geometry_data (locations[point], current_points[point], new_solution_indices);
+ internal::PointValueHistoryImplementation::PointGeometryData<dim> new_point_geometry_data (locations[point], current_points[point], new_solution_indices);
point_geometry_data.push_back (new_point_geometry_data);
unsigned int n_stored = mask->second.n_selected_components(dof_handler->get_fe(0).n_components ());
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (unsigned int data_store_index = 0; point != point_geometry_data.end (); ++point, ++data_store_index)
{
// Look up the components to add
Tensor< 2, dim, typename VectorType::value_type >()));
// Loop over points and find correct cell
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (unsigned int data_store_index = 0; point != point_geometry_data.end (); ++point, ++data_store_index)
{
// we now have a point to query, need to know what cell it is in
unsigned int n_stored = mask->second.n_selected_components(dof_handler->get_fe(0).n_components ());
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
Vector <number> value (dof_handler->get_fe(0).n_components());
for (unsigned int data_store_index = 0; point != point_geometry_data.end (); ++point, ++data_store_index)
{
// the number of dofs has changed.
//AssertThrow (!triangulation_changed, ExcDoFHandlerChanged ());
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (unsigned int data_store_index = 0; point != point_geometry_data.end (); ++point, ++data_store_index)
{
// for each point, open a file to
Vector<double> dof_vector (dof_handler->n_dofs ());
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (; point != point_geometry_data.end (); ++point)
{
for (unsigned int component = 0; component < dof_handler->get_fe(0).n_components (); component++)
AssertThrow (!triangulation_changed, ExcDoFHandlerChanged ());
std::vector <std::vector <Point <dim> > > actual_points;
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (; point != point_geometry_data.end (); ++point)
{
std::vector<Point<dim> > evaluation_points;
// Loop over points and find correct cell
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
for (unsigned int data_store_index = 0; point != point_geometry_data.end (); ++point, ++data_store_index)
{
// we now have a point to query,
out << "Have_dof_handler: " << have_dof_handler << "\n";
out << "Geometric Data" << "\n";
- typename std::vector <internal::PointValueHistory::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
+ typename std::vector <internal::PointValueHistoryImplementation::PointGeometryData <dim> >::iterator point = point_geometry_data.begin ();
if (point == point_geometry_data.end ())
{
out << "No points stored currently\n";
-DEAL::Exceptions::DataOut::ExcInvalidNumberOfNames (deduced_names.size(), dof_handler->get_fe(0).n_components())
-DEAL::Exceptions::DataOut::ExcInvalidNumberOfNames (deduced_names.size(), dof_handler->get_fe(0).n_components())
+DEAL::Exceptions::DataOutImplementation::ExcInvalidNumberOfNames (deduced_names.size(), dof_handler->get_fe(0).n_components())
+DEAL::Exceptions::DataOutImplementation::ExcInvalidNumberOfNames (deduced_names.size(), dof_handler->get_fe(0).n_components())
DEAL::OK
eigenvalues[i] = matrix.eigenvalue(i);
std::sort(eigenvalues.begin(), eigenvalues.end(),
- internal::SolverGMRES::complex_less_pred);
+ internal::SolverGMRESImplementation::complex_less_pred);
deallog << "Actual eigenvalues: ";
for (unsigned int i=0; i<n; ++i)
// Create to distinct linear operators:
- typedef dealii::internal::LinearOperator::EmptyPayload Payload;
+ typedef dealii::internal::LinearOperatorImplementation::EmptyPayload Payload;
LinearOperator<LeftVector, RightVector, Payload> multiply2;
multiply2.vmult = [](LeftVector &v, const RightVector &u)
{
// Create to distinct linear operators:
- typedef dealii::internal::LinearOperator::EmptyPayload Payload;
+ typedef dealii::internal::LinearOperatorImplementation::EmptyPayload Payload;
LinearOperator<LeftVector, RightVector, Payload> multiply2;
multiply2.vmult = [](LeftVector &v, const RightVector &u)
{
const auto lo_A = linear_operator<VECTOR>(A);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A = linear_operator<VECTOR,VECTOR,PAYLOAD>(A);
PRECONDITIONER preconditioner;
const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR>(A, preconditioner);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR,PAYLOAD>(A, preconditioner);
// Singular operation
{
// Stand-alone
deallog.push("S.A.");
- typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR,PAYLOAD>(preconditioner);
// Singular operation
const auto lo_A = linear_operator<VECTOR>(A);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A = linear_operator<VECTOR,VECTOR,PAYLOAD>(A);
SolverControl solver_control (100, 1.0e-10);
// // test_solver<SLVR> (A, b);
//
// typedef dealii::TrilinosWrappers::MPI::Vector VectorType;
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadType;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadType;
// // TODO: Full template expansion required for composite operator. Can one prevent this?
// // i.e. is 'const auto lo_A = linear_operator<VectorType>(A);' possible?
// const auto lo_A = linear_operator<VectorType,VectorType,PayloadType>(A);
const auto lo_A = linear_operator<VECTOR>(A);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A = linear_operator<VECTOR,VECTOR,PAYLOAD>(A);
PRECONDITIONER preconditioner;
const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR>(A, preconditioner);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR,PAYLOAD>(A, preconditioner);
// Singular operation
{
// Stand-alone
deallog.push("S.A.");
- typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
const auto lo_A_inv_approx = linear_operator<VECTOR,VECTOR,PAYLOAD>(preconditioner);
// Singular operation
const auto lo_A = linear_operator<VECTOR>(A);
// Note: The above should be equivalent to the following:
//
- // typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PAYLOAD;
+ // typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PAYLOAD;
// const auto lo_A = linear_operator<VECTOR,VECTOR,PAYLOAD>(A);
SolverControl solver_control (100, 1.0e-10, false,false);
const double tol = 1e-12;
typedef dealii::TrilinosWrappers::SparseMatrix MatrixType;
typedef dealii::TrilinosWrappers::MPI::Vector VectorType;
- typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadType;
+ typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadType;
typedef typename PayloadType::VectorType PayloadVectorType;
typedef dealii::types::global_dof_index size_type;
const double tol = 1e-12;
typedef dealii::TrilinosWrappers::SparseMatrix MatrixType;
typedef dealii::TrilinosWrappers::MPI::Vector VectorType;
- typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadType;
+ typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload PayloadType;
typedef typename PayloadType::VectorType PayloadVectorType;
typedef dealii::types::global_dof_index size_type;
}
template <class NUMBER>
-void output_arnoldi_vectors_norms(const internal::SolverGMRES::TmpVectors<Vector<NUMBER> > &tmp_vector,const std::string &text)
+void output_arnoldi_vectors_norms(const internal::SolverGMRESImplementation::TmpVectors<Vector<NUMBER> > &tmp_vector,const std::string &text)
{
deallog << text << std::endl;
for (unsigned int i=0; i<tmp_vector.size(); ++i)
namespace internal
{
- namespace Vector
+ namespace VectorImplementation
{
extern unsigned int minimum_parallel_grain_size;
}
- namespace SparseMatrix
+ namespace SparseMatrixImplementation
{
extern unsigned int minimum_parallel_grain_size;
}
{
SetGrainSizes ()
{
- internal::Vector::minimum_parallel_grain_size = 2;
- internal::SparseMatrix::minimum_parallel_grain_size = 2;
+ internal::VectorImplementation::minimum_parallel_grain_size = 2;
+ internal::SparseMatrixImplementation::minimum_parallel_grain_size = 2;
}
} set_grain_sizes;