template <int dim, int spacedim, typename number>
struct Scratch
{
- Scratch(
- const ::dealii::hp::FECollection<dim, spacedim> &fe,
- const UpdateFlags update_flags,
- const Function<spacedim,
- typename numbers::NumberTraits<number>::real_type>
- * coefficient,
- const Function<spacedim, number> * rhs_function,
- const ::dealii::hp::QCollection<dim> & quadrature,
- const ::dealii::hp::MappingCollection<dim, spacedim> &mapping) :
+ Scratch(const ::dealii::hp::FECollection<dim, spacedim> &fe,
+ const UpdateFlags update_flags,
+ const Function<spacedim, number> * coefficient,
+ const Function<spacedim, number> * rhs_function,
+ const ::dealii::hp::QCollection<dim> & quadrature,
+ const ::dealii::hp::MappingCollection<dim, spacedim> &mapping) :
fe_collection(fe),
quadrature_collection(quadrature),
mapping_collection(mapping),
coefficient_values(quadrature_collection.max_n_quadrature_points()),
coefficient_vector_values(
quadrature_collection.max_n_quadrature_points(),
- dealii::Vector<typename numbers::NumberTraits<number>::real_type>(
- fe_collection.n_components())),
+ dealii::Vector<number>(fe_collection.n_components())),
rhs_values(quadrature_collection.max_n_quadrature_points()),
rhs_vector_values(
quadrature_collection.max_n_quadrature_points(),
::dealii::hp::FEValues<dim, spacedim> x_fe_values;
- std::vector<typename numbers::NumberTraits<number>::real_type>
- coefficient_values;
- std::vector<
- dealii::Vector<typename numbers::NumberTraits<number>::real_type>>
- coefficient_vector_values;
+ std::vector<number> coefficient_values;
+ std::vector<dealii::Vector<number>> coefficient_vector_values;
std::vector<number> rhs_values;
std::vector<dealii::Vector<number>> rhs_vector_values;
- const Function<spacedim,
- typename numbers::NumberTraits<number>::real_type>
- * coefficient;
+ const Function<spacedim, number> *coefficient;
const Function<spacedim, number> *rhs_function;
const UpdateFlags update_flags;
struct CopyData
{
std::vector<types::global_dof_index> dof_indices;
- FullMatrix<typename numbers::NumberTraits<number>::real_type>
- cell_matrix;
- dealii::Vector<number> cell_rhs;
- const ConstraintMatrix *constraints;
+ FullMatrix<number> cell_matrix;
+ dealii::Vector<number> cell_rhs;
+ const AffineConstraints<number> * constraints;
};
} // namespace AssemblerData
else
{
data.coefficient_vector_values.resize(
- n_q_points,
- dealii::Vector<
- typename numbers::NumberTraits<number>::real_type>(
- n_components));
+ n_q_points, dealii::Vector<number>(n_components));
data.coefficient->vector_value_list(
fe_values.get_quadrature_points(),
data.coefficient_vector_values);
if ((n_components == 1) ||
(fe.system_to_component_index(j).first == component_i))
{
- const double *phi_j = &fe_values.shape_value(j, 0);
- typename numbers::NumberTraits<number>::real_type add_data =
- 0;
+ const double *phi_j = &fe_values.shape_value(j, 0);
+ number add_data = 0;
if (use_coefficient)
{
if (data.coefficient->n_components == 1)
// symmetry again
for (unsigned int j = i; j < dofs_per_cell; ++j)
{
- typename numbers::NumberTraits<number>::real_type add_data = 0;
+ number add_data = 0;
for (unsigned int comp_i = 0; comp_i < n_components; ++comp_i)
if (fe.get_nonzero_components(i)[comp_i] &&
fe.get_nonzero_components(j)[comp_i])
std::vector<types::global_dof_index> dofs;
std::vector<std::vector<bool>> dof_is_on_face;
typename DoFHandlerType::active_cell_iterator cell;
- std::vector<
- FullMatrix<typename numbers::NumberTraits<number>::real_type>>
- cell_matrix;
- std::vector<Vector<number>> cell_vector;
+ std::vector<FullMatrix<number>> cell_matrix;
+ std::vector<Vector<number>> cell_vector;
};
const Quadrature<dim> & q,
SparseMatrix<number> & matrix,
const Function<spacedim, number> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<number> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const Quadrature<dim> & q,
SparseMatrix<number> & matrix,
const Function<spacedim, number> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<number> & constraints)
{
create_mass_matrix(StaticMappingQ1<dim, spacedim>::mapping,
dof,
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints)
+ create_mass_matrix(const Mapping<dim, spacedim> & mapping,
+ const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const coefficient,
+ const AffineConstraints<number> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
typename DoFHandler<dim, spacedim>::active_cell_iterator,
number>,
std::bind(
- &MatrixCreator::internal::copy_local_to_global<
- number,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type>,
- Vector<number>>,
+ &MatrixCreator::internal::
+ copy_local_to_global<number, SparseMatrix<number>, Vector<number>>,
std::placeholders::_1,
&matrix,
&rhs_vector),
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints)
+ create_mass_matrix(const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const coefficient,
+ const AffineConstraints<number> & constraints)
{
create_mass_matrix(StaticMappingQ1<dim, spacedim>::mapping,
dof,
const hp::QCollection<dim> & q,
SparseMatrix<number> & matrix,
const Function<spacedim, number> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<number> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const hp::QCollection<dim> & q,
SparseMatrix<number> & matrix,
const Function<spacedim, number> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<number> & constraints)
{
create_mass_matrix(hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints)
+ create_mass_matrix(const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const coefficient,
+ const AffineConstraints<number> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
typename hp::DoFHandler<dim, spacedim>::active_cell_iterator,
number>,
std::bind(
- &MatrixCreator::internal::copy_local_to_global<
- number,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type>,
- Vector<number>>,
+ &MatrixCreator::internal::
+ copy_local_to_global<number, SparseMatrix<number>, Vector<number>>,
std::placeholders::_1,
&matrix,
&rhs_vector),
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints)
+ create_mass_matrix(const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const coefficient,
+ const AffineConstraints<number> & constraints)
{
create_mass_matrix(hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
dof,
FiniteElement<dim, spacedim> const & fe,
Quadrature<dim - 1> const & q,
std::map<types::boundary_id, const Function<spacedim, number> *> const
- &boundary_functions,
- Function<spacedim,
- typename numbers::NumberTraits<number>::real_type> const
- *const coefficient,
- std::vector<unsigned int> const &component_mapping)
+ & boundary_functions,
+ Function<spacedim, number> const *const coefficient,
+ std::vector<unsigned int> const & component_mapping)
{
// Most assertions for this function are in the calling function
// two variables for the coefficient, one for the two cases
// indicated in the name
- std::vector<typename numbers::NumberTraits<number>::real_type>
- coefficient_values(fe_values.n_quadrature_points, 1.);
- std::vector<Vector<typename numbers::NumberTraits<number>::real_type>>
- coefficient_vector_values(
- fe_values.n_quadrature_points,
- Vector<typename numbers::NumberTraits<number>::real_type>(
- n_components));
+ std::vector<number> coefficient_values(fe_values.n_quadrature_points, 1.);
+ std::vector<Vector<number>> coefficient_vector_values(
+ fe_values.n_quadrature_points, Vector<number>(n_components));
const bool coefficient_is_vector =
(coefficient != nullptr && coefficient->n_components != 1);
std::map<types::boundary_id, const Function<spacedim, number> *> const
& boundary_functions,
std::vector<types::global_dof_index> const &dof_to_boundary_mapping,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- Vector<number> &rhs_vector)
+ SparseMatrix<number> & matrix,
+ Vector<number> & rhs_vector)
{
// now transfer cell matrix and vector to the whole boundary matrix
//
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const Mapping<dim, spacedim> & mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- std::vector<unsigned int> component_mapping)
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const coefficient,
+ std::vector<unsigned int> component_mapping)
{
// what would that be in 1d? the
// identity matrix on the boundary
hp::FECollection<dim, spacedim> const & fe_collection,
hp::QCollection<dim - 1> const & q,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- &boundary_functions,
- Function<spacedim,
- typename numbers::NumberTraits<number>::real_type> const
- *const coefficient,
- std::vector<unsigned int> const &component_mapping)
+ & boundary_functions,
+ Function<spacedim, number> const *const coefficient,
+ std::vector<unsigned int> const & component_mapping)
{
const unsigned int n_components = fe_collection.n_components();
const unsigned int n_function_components =
// two variables for the coefficient,
// one for the two cases indicated in
// the name
- std::vector<typename numbers::NumberTraits<number>::real_type>
- coefficient_values;
- std::vector<Vector<typename numbers::NumberTraits<number>::real_type>>
- coefficient_vector_values;
+ std::vector<number> coefficient_values;
+ std::vector<Vector<number>> coefficient_vector_values;
const bool coefficient_is_vector =
(coefficient != nullptr && coefficient->n_components != 1);
if (fe_is_system)
// FE has several components
{
- coefficient_vector_values.resize(
- fe_values.n_quadrature_points,
- Vector<typename numbers::NumberTraits<number>::real_type>(
- n_components));
+ coefficient_vector_values.resize(fe_values.n_quadrature_points,
+ Vector<number>(n_components));
coefficient_values.resize(fe_values.n_quadrature_points, 1.);
rhs_values_system.resize(fe_values.n_quadrature_points,
std::map<types::boundary_id, const Function<spacedim, number> *> const
& boundary_functions,
std::vector<types::global_dof_index> const &dof_to_boundary_mapping,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- Vector<number> &rhs_vector)
+ SparseMatrix<number> & matrix,
+ Vector<number> & rhs_vector)
{
// now transfer cell matrix and vector to the whole boundary matrix
//
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *> &rhs,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a,
- std::vector<unsigned int> component_mapping)
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const a,
+ std::vector<unsigned int> component_mapping)
{
create_boundary_mass_matrix(StaticMappingQ1<dim, spacedim>::mapping,
dof,
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const coefficient,
- std::vector<unsigned int> component_mapping)
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const coefficient,
+ std::vector<unsigned int> component_mapping)
{
// what would that be in 1d? the
// identity matrix on the boundary
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const hp::DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *> &rhs,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a,
- std::vector<unsigned int> component_mapping)
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const a,
+ std::vector<unsigned int> component_mapping)
{
create_boundary_mass_matrix(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
const Quadrature<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> &constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const Quadrature<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> &constraints)
{
create_laplace_matrix(StaticMappingQ1<dim, spacedim>::mapping,
dof,
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> &constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> &constraints)
{
create_laplace_matrix(StaticMappingQ1<dim, spacedim>::mapping,
dof,
const hp::QCollection<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const hp::QCollection<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> & constraints)
{
create_laplace_matrix(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> & constraints)
{
Assert(matrix.m() == dof.n_dofs(),
ExcDimensionMismatch(matrix.m(), dof.n_dofs()));
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const coefficient,
- const ConstraintMatrix & constraints)
+ const AffineConstraints<double> & constraints)
{
create_laplace_matrix(
hp::StaticMappingQ1<dim, spacedim>::mapping_collection,
#include <deal.II/dofs/function_map.h>
-#include <deal.II/lac/constraint_matrix.h>
+#include <deal.II/lac/affine_constraints.h>
#include <map>
* hanging nodes are not eliminated. The reason is that you may want to add
* several matrices and could then condense afterwards only once, instead of
* for every matrix. To actually do computations with these matrices, you have
- * to condense the matrix using the ConstraintMatrix::condense function; you
+ * to condense the matrix using the AffineConstraints::condense function; you
* also have to condense the right hand side accordingly and distribute the
* solution afterwards. Alternatively, you can give an optional argument
- * ConstraintMatrix that writes cell matrix (and vector) entries with
+ * AffineConstraints that writes cell matrix (and vector) entries with
* distribute_local_to_global into the global matrix and vector. This way,
- * adding several matrices from different sources is more complicated and you
- * should make sure that you do not mix different ways of applying
+ * adding several matrices from different sources is more complicated and
+ * you should make sure that you do not mix different ways of applying
* constraints. Particular caution is necessary when the given constraint
* matrix contains inhomogeneous constraints: In that case, the matrix
* assembled this way must be the only matrix (or you need to assemble the
*/
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<number> & matrix,
- const Function<spacedim, number> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ create_mass_matrix(
+ const Mapping<dim, spacedim> & mapping,
+ const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Call the create_mass_matrix() function, see above, with
*/
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<number> & matrix,
- const Function<spacedim, number> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ create_mass_matrix(
+ const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Assemble the mass matrix and a right hand side vector. If no coefficient
template <int dim, int spacedim, typename number>
void
create_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const Mapping<dim, spacedim> & mapping,
+ const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Call the create_mass_matrix() function, see above, with
template <int dim, int spacedim, typename number>
void
create_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const DoFHandler<dim, spacedim> & dof,
+ const Quadrature<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Same function as above, but for hp objects.
*/
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(const hp::MappingCollection<dim, spacedim> &mapping,
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<number> & matrix,
- const Function<spacedim, number> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ create_mass_matrix(
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Same function as above, but for hp objects.
*/
template <int dim, int spacedim, typename number>
void
- create_mass_matrix(const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<number> & matrix,
- const Function<spacedim, number> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ create_mass_matrix(
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Same function as above, but for hp objects.
template <int dim, int spacedim, typename number>
void
create_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
* Same function as above, but for hp objects.
template <int dim, int spacedim, typename number>
void
create_mass_matrix(
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
- const Function<spacedim, number> & rhs,
- Vector<number> & rhs_vector,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim> & q,
+ SparseMatrix<number> & matrix,
+ const Function<spacedim, number> & rhs,
+ Vector<number> & rhs_vector,
+ const Function<spacedim, number> *const a = nullptr,
+ const AffineConstraints<number> &constraints = AffineConstraints<number>());
/**
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const Mapping<dim, spacedim> & mapping,
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const Mapping<dim, spacedim> & mapping,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const weight = 0,
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const weight = 0,
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const DoFHandler<dim, spacedim> & dof,
- const Quadrature<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const DoFHandler<dim, spacedim> &dof,
+ const Quadrature<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const hp::MappingCollection<dim, spacedim> & mapping,
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const hp::MappingCollection<dim, spacedim> &mapping,
+ const hp::DoFHandler<dim, spacedim> & dof,
+ const hp::QCollection<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
template <int dim, int spacedim, typename number>
void
create_boundary_mass_matrix(
- const hp::DoFHandler<dim, spacedim> & dof,
- const hp::QCollection<dim - 1> & q,
- SparseMatrix<typename numbers::NumberTraits<number>::real_type> &matrix,
+ const hp::DoFHandler<dim, spacedim> &dof,
+ const hp::QCollection<dim - 1> & q,
+ SparseMatrix<number> & matrix,
const std::map<types::boundary_id, const Function<spacedim, number> *>
- & boundary_functions,
- Vector<number> & rhs_vector,
- std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<spacedim, typename numbers::NumberTraits<number>::real_type>
- *const a = nullptr,
+ & boundary_functions,
+ Vector<number> & rhs_vector,
+ std::vector<types::global_dof_index> & dof_to_boundary_mapping,
+ const Function<spacedim, number> *const a = nullptr,
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
const Quadrature<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Call the create_laplace_matrix() function, see above, with
const Quadrature<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Assemble the Laplace matrix and a right hand side vector. If no
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Call the create_laplace_matrix() function, see above, with
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Like the functions above, but for hp dof handlers, mappings, and
const hp::QCollection<dim> & q,
SparseMatrix<double> & matrix,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Like the functions above, but for hp dof handlers, mappings, and
const hp::DoFHandler<dim, spacedim> &dof,
const hp::QCollection<dim> & q,
SparseMatrix<double> & matrix,
- const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const Function<spacedim> *const a = nullptr,
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Like the functions above, but for hp dof handlers, mappings, and
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix &constraints = ConstraintMatrix());
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Like the functions above, but for hp dof handlers, mappings, and
SparseMatrix<double> & matrix,
const Function<spacedim> & rhs,
Vector<double> & rhs_vector,
- const Function<spacedim> *const a = nullptr,
- const ConstraintMatrix & constraints = ConstraintMatrix());
+ const Function<spacedim> *const a = nullptr,
+ const AffineConstraints<double> &constraints = AffineConstraints<double>());
/**
* Exception
// ---------------------------------------------------------------------
//
-// Copyright (C) 2010 - 2017 by the deal.II authors
+// Copyright (C) 2010 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
const Quadrature<deal_II_dimension> & q,
SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<scalar> & constraints);
template void MatrixCreator::
create_mass_matrix<deal_II_dimension, deal_II_space_dimension, scalar>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const Quadrature<deal_II_dimension> & q,
SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<scalar> & constraints);
// hp versions of functions
template void MatrixCreator::
const hp::QCollection<deal_II_dimension> & q,
SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<scalar> & constraints);
template void MatrixCreator::
create_mass_matrix<deal_II_dimension, deal_II_space_dimension, scalar>(
const hp::QCollection<deal_II_dimension> & q,
SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<scalar> & constraints);
#endif
}
const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const Quadrature<deal_II_dimension> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> & matrix,
+ SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> &rhs_vector,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints);
+ Vector<scalar> & rhs_vector,
+ const Function<deal_II_space_dimension, scalar> *const coefficient,
+ const AffineConstraints<scalar> & constraints);
template void MatrixCreator::
create_mass_matrix<deal_II_dimension, deal_II_space_dimension, scalar>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const Quadrature<deal_II_dimension> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> & matrix,
+ SparseMatrix<scalar> & matrix,
const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> &rhs_vector,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints);
+ Vector<scalar> & rhs_vector,
+ const Function<deal_II_space_dimension, scalar> *const coefficient,
+ const AffineConstraints<scalar> & constraints);
// hp version
template void MatrixCreator::
&mapping,
const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const hp::QCollection<deal_II_dimension> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> &matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints);
+ SparseMatrix<scalar> & matrix,
+ const Function<deal_II_space_dimension, scalar> & rhs,
+ Vector<scalar> & rhs_vector,
+ const Function<deal_II_space_dimension, scalar> *const coefficient,
+ const AffineConstraints<scalar> & constraints);
template void MatrixCreator::
create_mass_matrix<deal_II_dimension, deal_II_space_dimension, scalar>(
const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const hp::QCollection<deal_II_dimension> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> &matrix,
- const Function<deal_II_space_dimension, scalar> & rhs,
- Vector<scalar> & rhs_vector,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type>
- *const coefficient,
- const ConstraintMatrix &constraints);
+ SparseMatrix<scalar> & matrix,
+ const Function<deal_II_space_dimension, scalar> & rhs,
+ Vector<scalar> & rhs_vector,
+ const Function<deal_II_space_dimension, scalar> *const coefficient,
+ const AffineConstraints<scalar> & constraints);
#endif
}
scalar>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
const Quadrature<deal_II_dimension - 1> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> & matrix,
+ SparseMatrix<scalar> & matrix,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &rhs,
Vector<scalar> & rhs_vector,
std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type> *const a,
+ const Function<deal_II_space_dimension, scalar> *const a,
std::vector<unsigned int>);
template void
const Mapping<deal_II_dimension, deal_II_space_dimension> &,
const DoFHandler<deal_II_dimension, deal_II_space_dimension> & dof,
const Quadrature<deal_II_dimension - 1> & q,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> & matrix,
+ SparseMatrix<scalar> & matrix,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &rhs,
Vector<scalar> & rhs_vector,
std::vector<types::global_dof_index> &dof_to_boundary_mapping,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type> *const a,
+ const Function<deal_II_space_dimension, scalar> *const a,
std::vector<unsigned int>);
template void
const hp::MappingCollection<deal_II_dimension, deal_II_space_dimension> &,
const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
const hp::QCollection<deal_II_dimension - 1> &,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> &,
+ SparseMatrix<scalar> &,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &,
Vector<scalar> &,
std::vector<types::global_dof_index> &,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type> *const,
+ const Function<deal_II_space_dimension, scalar> *const,
std::vector<unsigned int>);
template void
scalar>(
const hp::DoFHandler<deal_II_dimension, deal_II_space_dimension> &,
const hp::QCollection<deal_II_dimension - 1> &,
- SparseMatrix<numbers::NumberTraits<scalar>::real_type> &,
+ SparseMatrix<scalar> &,
const std::map<types::boundary_id,
const Function<deal_II_space_dimension, scalar> *> &,
Vector<scalar> &,
std::vector<types::global_dof_index> &,
- const Function<deal_II_space_dimension,
- numbers::NumberTraits<scalar>::real_type> *const,
+ const Function<deal_II_space_dimension, scalar> *const,
std::vector<unsigned int>);
#endif
}
const Quadrature<deal_II_dimension> & q,
SparseMatrix<double> & matrix,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const Mapping<deal_II_dimension> & mapping,
const DoFHandler<deal_II_dimension> & dof,
const Quadrature<deal_II_dimension> & q,
SparseMatrix<double> & matrix,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const Mapping<deal_II_dimension> & mapping,
const DoFHandler<deal_II_dimension> & dof,
const Function<deal_II_dimension> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const DoFHandler<deal_II_dimension> & dof,
const Quadrature<deal_II_dimension> & q,
const Function<deal_II_dimension> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
// hp versions of create_laplace_matrix
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const hp::QCollection<deal_II_dimension> &q,
SparseMatrix<double> & matrix,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const hp::MappingCollection<deal_II_dimension> &mapping,
const hp::DoFHandler<deal_II_dimension> & dof,
const hp::QCollection<deal_II_dimension> & q,
SparseMatrix<double> & matrix,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const hp::MappingCollection<deal_II_dimension> &mapping,
const hp::DoFHandler<deal_II_dimension> & dof,
const Function<deal_II_dimension> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension>(
const hp::DoFHandler<deal_II_dimension> & dof,
const hp::QCollection<deal_II_dimension> &q,
const Function<deal_II_dimension> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_dimension> *const coefficient,
- const ConstraintMatrix & constraints);
+ const AffineConstraints<double> & constraints);
#endif
}
const Quadrature<deal_II_dimension> & q,
SparseMatrix<double> & matrix,
const Function<deal_II_space_dimension, double> *const coefficient,
- const ConstraintMatrix &constraints);
+ const AffineConstraints<double> &constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const Quadrature<deal_II_dimension> & q,
SparseMatrix<double> & matrix,
const Function<deal_II_space_dimension, double> *const coefficient,
- const ConstraintMatrix &constraints);
+ const AffineConstraints<double> &constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension>(
const Mapping<deal_II_dimension, deal_II_space_dimension> & mapping,
const Function<deal_II_space_dimension, double> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_space_dimension, double> *const coefficient,
- const ConstraintMatrix &constraints);
+ const AffineConstraints<double> &constraints);
template void MatrixCreator::create_laplace_matrix<deal_II_dimension,
deal_II_space_dimension>(
const DoFHandler<deal_II_dimension, deal_II_space_dimension> &dof,
const Function<deal_II_space_dimension, double> & rhs,
Vector<double> & rhs_vector,
const Function<deal_II_space_dimension, double> *const coefficient,
- const ConstraintMatrix &constraints);
+ const AffineConstraints<double> &constraints);
#endif
}
projects / dealii.git / commitdiff