Classes | |
class | ExcComponentMismatch |
struct | IteratorRange |
Static Public Member Functions | |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static 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 > *const a=0) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static 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 > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix (const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim-1 > &q, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const weight=0, std::vector< unsigned int > component_mapping=std::vector< unsigned int >()) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix (const DoFHandler< dim, spacedim > &dof, const Quadrature< dim-1 > &q, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const a=0, std::vector< unsigned int > component_mapping=std::vector< unsigned int >()) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim-1 > &q, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const a=0, std::vector< unsigned int > component_mapping=std::vector< unsigned int >()) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix (const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim-1 > &q, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const a=0, std::vector< unsigned int > component_mapping=std::vector< unsigned int >()) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix (const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a=0) |
Static Private Member Functions | |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix_1 (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > *const a, const IteratorRange< DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix_2 (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a, const IteratorRange< DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix_1 (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > *const a, const IteratorRange< hp::DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, typename number , int spacedim> | |
static void | create_mass_matrix_2 (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< number > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a, const IteratorRange< hp::DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix_1 (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a, const IteratorRange< DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix_2 (const Mapping< dim, spacedim > &mapping, const DoFHandler< dim, spacedim > &dof, const Quadrature< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a, const IteratorRange< DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix_1 (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > *const a, const IteratorRange< hp::DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_laplace_matrix_2 (const hp::MappingCollection< dim, spacedim > &mapping, const hp::DoFHandler< dim, spacedim > &dof, const hp::QCollection< dim > &q, SparseMatrix< double > &matrix, const Function< spacedim > &rhs, Vector< double > &rhs_vector, const Function< spacedim > *const a, const IteratorRange< hp::DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix_1 (std_cxx1x::tuple< const Mapping< dim, spacedim > &, const DoFHandler< dim, spacedim > &, const Quadrature< dim-1 > & > commons, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const coefficient, const std::vector< unsigned int > &component_mapping, const IteratorRange< DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
template<int dim, int spacedim> | |
static void | create_boundary_mass_matrix_1 (std_cxx1x::tuple< const hp::MappingCollection< dim, spacedim > &, const hp::DoFHandler< dim, spacedim > &, const hp::QCollection< dim-1 > & > commons, SparseMatrix< double > &matrix, const typename FunctionMap< spacedim >::type &boundary_functions, Vector< double > &rhs_vector, std::vector< unsigned int > &dof_to_boundary_mapping, const Function< spacedim > *const coefficient, const std::vector< unsigned int > &component_mapping, const IteratorRange< hp::DoFHandler< dim, spacedim > > range, Threads::ThreadMutex &mutex) |
There exist two versions of each function. One with a Mapping argument and one without. If a code uses a mapping different from MappingQ1 the functions with mapping argument should be used. Code that uses only MappingQ1 may also use the functions without Mapping argument. Each of these latter functions create a MappingQ1 object and just call the respective functions with that object as mapping argument.
All functions take a sparse matrix object to hold the matrix to be created. The functions assume that the matrix is initialized with a sparsity pattern (SparsityPattern) corresponding to the given degree of freedom handler, i.e. the sparsity structure is already as needed. You can do this by calling the DoFTools::make_sparsity_pattern() function.
Furthermore it is assumed that no relevant data is in the matrix. Some entries will be overwritten and some others will contain invalid data if the matrix wasn't empty before. Therefore you may want to clear the matrix before assemblage.
All created matrices are `raw': they are not condensed, i.e. 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 ConstraintMatrixcondense
function; you also have to condense the right hand side accordingly and distribute the solution afterwards.
If you want to use boundary conditions with the matrices generated by the functions of this class, you have to use a function like ProblemBase<>::apply_dirichlet_bc
to matrix and right hand side.
At present there are functions to create the following matrices:
create_mass_matrix:
create the matrix with entries
A coefficient may be given to evaluate instead.
create_laplace_matrix:
create the matrix with entries
Again, a coefficient may be given to evaluate instead.
Make sure that the order of the Quadrature formula given to these functions is sufficiently high to compute the matrices with the required accuracy. For the choice of this quadrature rule you need to take into account the polynomial degree of the FiniteElement basis functions, the roughness of the coefficient a
, as well as the degree of the given Mapping
(if any).
Note, that for system elements the mass matrix and the laplace matrix is implemented such that each components couple only with itself, i.e. there is no coupling of shape functions belonging to different components. If the degrees of freedom have been sorted according to their vector component (e.g., using DoFRenumbering::component_wise()), then the resulting matrices will be block diagonal.
If the finite element for which the mass matrix or the laplace matrix is to be built has more than one component, this function accepts a single coefficient as well as a vector valued coefficient function. For the latter case make sure that the number of components coincides with the number of components of the system finite element.
The create_boundary_mass_matrix() creates the matrix with entries , where
is the union of boundary parts with indicators contained in a FunctionMap passed to the function (i.e. if you want to set up the mass matrix for the parts of the boundary with indicators zero and 2, you pass the function a map of
unsigned char
s as parameter boundary_functions
containing the keys zero and 2). The size of the matrix is equal to the number of degrees of freedom that have support on the boundary, i.e. it is not a matrix on all degrees of freedom, but only a subset. (The in the formula are this subsect of basis functions which have at least part of their support on
.) In order to determine which shape functions are to be considered, and in order to determine in which order, the function takes a
dof_to_boundary_mapping
; this object maps global DoF numbers to a numbering of the degrees of freedom located on the boundary, and can be obtained using the function DoFTools::map_dof_to_boundary_indices().
In order to work, the function needs a matrix of the correct size, built on top of a corresponding sparsity pattern. Since we only work on a subset of the degrees of freedom, we can't use the matrices and sparsity patterns that are created for the entire set of degrees of freedom. Rather, you should use the DoFHandlermake_boundary_sparsity_pattern()
function to create the correct sparsity pattern, and build a matrix on top of it.
Note that at present there is no function that computes the mass matrix for all shape functions, though such a function would be trivial to implement.
In many cases, you will not only want to build the matrix, but also a right hand side, which will give a vector with . For this purpose, each function exists in two versions, one only building the matrix and one also building the right hand side vector. If you want to create a right hand side vector without creating a matrix, you can use the VectorTools::create_right_hand_side() function. The use of the latter may be useful if you want to create many right hand side vectors.
static void MatrixCreator::create_mass_matrix | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Assemble the mass matrix. If no coefficient is given, it is assumed to be unity.
If the library is configured to use multithreading, this function works in parallel.
See the general doc of this class for more information.
static void MatrixCreator::create_mass_matrix | ( | const DoFHandler< dim, spacedim > & | dof, | |
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Calls the create_mass_matrix() function, see above, with mapping=MappingQ1<dim>()
.
static void MatrixCreator::create_mass_matrix | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Assemble the mass matrix and a right hand side vector. If no coefficient is given, it is assumed to be unity.
If the library is configured to use multithreading, this function works in parallel.
See the general doc of this class for more information.
static void MatrixCreator::create_mass_matrix | ( | const DoFHandler< dim, spacedim > & | dof, | |
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Calls the create_mass_matrix() function, see above, with mapping=MappingQ1<dim>()
.
static void MatrixCreator::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 > *const | a = 0 | |||
) | [inline, static] |
Same function as above, but for hp objects.
static void MatrixCreator::create_mass_matrix | ( | const hp::DoFHandler< dim, spacedim > & | dof, | |
const hp::QCollection< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Same function as above, but for hp objects.
static void MatrixCreator::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 > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Same function as above, but for hp objects.
static void MatrixCreator::create_mass_matrix | ( | const hp::DoFHandler< dim, spacedim > & | dof, | |
const hp::QCollection< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Same function as above, but for hp objects.
static void MatrixCreator::create_boundary_mass_matrix | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim-1 > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | weight = 0 , |
|||
std::vector< unsigned int > | component_mapping = std::vector< unsigned int >() | |||
) | [inline, static] |
Assemble the mass matrix and a right hand side vector along the boundary.
The matrix is assumed to already be initialized with a suiting sparsity pattern (the DoFHandler provides an appropriate function).
If the library is configured to use multithreading, this function works in parallel.
weight:
an optional weight for the computation of the mass matrix. If no weight is given, it is set to one.component_mapping:
if the components in boundary_functions
and dof
do not coincide, this vector allows them to be remapped. If the vector is not empty, it has to have one entry for each component in dof
. This entry is the component number in boundary_functions
that should be used for this component in dof
. By default, no remapping is applied.static void MatrixCreator::create_boundary_mass_matrix | ( | const DoFHandler< dim, spacedim > & | dof, | |
const Quadrature< dim-1 > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | a = 0 , |
|||
std::vector< unsigned int > | component_mapping = std::vector< unsigned int >() | |||
) | [inline, static] |
Calls the create_boundary_mass_matrix() function, see above, with mapping=MappingQ1<dim>()
.
static void MatrixCreator::create_boundary_mass_matrix | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim-1 > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | a = 0 , |
|||
std::vector< unsigned int > | component_mapping = std::vector< unsigned int >() | |||
) | [inline, static] |
Same function as above, but for hp objects.
static void MatrixCreator::create_boundary_mass_matrix | ( | const hp::DoFHandler< dim, spacedim > & | dof, | |
const hp::QCollection< dim-1 > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | a = 0 , |
|||
std::vector< unsigned int > | component_mapping = std::vector< unsigned int >() | |||
) | [inline, static] |
static void MatrixCreator::create_laplace_matrix | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Assemble the Laplace matrix. If no coefficient is given, it is assumed to be constant one.
If the library is configured to use multithreading, this function works in parallel.
See the general doc of this class for more information.
static void MatrixCreator::create_laplace_matrix | ( | const DoFHandler< dim, spacedim > & | dof, | |
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Calls the create_laplace_matrix() function, see above, with mapping=MappingQ1<dim>()
.
static void MatrixCreator::create_laplace_matrix | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Assemble the Laplace matrix and a right hand side vector. If no coefficient is given, it is assumed to be constant one.
If the library is configured to use multithreading, this function works in parallel.
See the general doc of this class for more information.
static void MatrixCreator::create_laplace_matrix | ( | const DoFHandler< dim, spacedim > & | dof, | |
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Calls the create_laplace_matrix() function, see above, with mapping=MappingQ1<dim>()
.
static void MatrixCreator::create_laplace_matrix | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Like the functions above, but for hp dof handlers, mappings, and quadrature collections.
static void MatrixCreator::create_laplace_matrix | ( | const hp::DoFHandler< dim, spacedim > & | dof, | |
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Like the functions above, but for hp dof handlers, mappings, and quadrature collections.
static void MatrixCreator::create_laplace_matrix | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Like the functions above, but for hp dof handlers, mappings, and quadrature collections.
static void MatrixCreator::create_laplace_matrix | ( | const hp::DoFHandler< dim, spacedim > & | dof, | |
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a = 0 | |||
) | [inline, static] |
Like the functions above, but for hp dof handlers, mappings, and quadrature collections.
static void MatrixCreator::create_mass_matrix_1 | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _1
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_mass_matrix_2 | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _2
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_mass_matrix_1 | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< hp::DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Same function as above, but for hp objects.
static void MatrixCreator::create_mass_matrix_2 | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< number > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< hp::DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
static void MatrixCreator::create_laplace_matrix_1 | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _1
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_laplace_matrix_2 | ( | const Mapping< dim, spacedim > & | mapping, | |
const DoFHandler< dim, spacedim > & | dof, | |||
const Quadrature< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _2
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_laplace_matrix_1 | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< hp::DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _1
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_laplace_matrix_2 | ( | const hp::MappingCollection< dim, spacedim > & | mapping, | |
const hp::DoFHandler< dim, spacedim > & | dof, | |||
const hp::QCollection< dim > & | q, | |||
SparseMatrix< double > & | matrix, | |||
const Function< spacedim > & | rhs, | |||
Vector< double > & | rhs_vector, | |||
const Function< spacedim > *const | a, | |||
const IteratorRange< hp::DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _2
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_boundary_mass_matrix_1 | ( | std_cxx1x::tuple< const Mapping< dim, spacedim > &, const DoFHandler< dim, spacedim > &, const Quadrature< dim-1 > & > | commons, | |
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | coefficient, | |||
const std::vector< unsigned int > & | component_mapping, | |||
const IteratorRange< DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Version of the same function (without suffix _1
) with the same argument list that operates only on an interval of iterators. Used for parallelization. The mutex is used to synchronise access to the matrix.
static void MatrixCreator::create_boundary_mass_matrix_1 | ( | std_cxx1x::tuple< const hp::MappingCollection< dim, spacedim > &, const hp::DoFHandler< dim, spacedim > &, const hp::QCollection< dim-1 > & > | commons, | |
SparseMatrix< double > & | matrix, | |||
const typename FunctionMap< spacedim >::type & | boundary_functions, | |||
Vector< double > & | rhs_vector, | |||
std::vector< unsigned int > & | dof_to_boundary_mapping, | |||
const Function< spacedim > *const | coefficient, | |||
const std::vector< unsigned int > & | component_mapping, | |||
const IteratorRange< hp::DoFHandler< dim, spacedim > > | range, | |||
Threads::ThreadMutex & | mutex | |||
) | [inline, static, private] |
Same as above, but for hp.