* the current cell, and store them internally. Similar functionality as the
* function DoFAccessor::get_interpolated_dof_values when no constraints are
* present, but it also includes constraints from hanging nodes, so one can
- * see it as a similar function to ConstraintMatrix::read_dof_values as
+ * see it as a similar function to AffineConstraints::read_dof_values as
* well. Note that if vectorization is enabled, the DoF values for several
* cells are set.
*
* If some constraints on the vector are inhomogeneous, use the function
* read_dof_values_plain instead and provide the vector with useful data
- * also in constrained positions by calling ConstraintMatrix::distribute.
+ * also in constrained positions by calling AffineConstraints::distribute.
* When accessing vector entries during the solution of linear systems, the
* temporary solution should always have homogeneous constraints and this
* method is the correct one.
* read_dof_values function, this function reads out the plain entries from
* vectors, without taking stored constraints into account. This way of
* access is appropriate when the constraints have been distributed on the
- * vector by a call to ConstraintMatrix::distribute previously. This
+ * vector by a call to AffineConstraints::distribute previously. This
* function is also necessary when inhomogeneous constraints are to be used,
* as MatrixFree can only handle homogeneous constraints. Note that if
* vectorization is enabled, the DoF values for several cells are set.
* Takes the values stored internally on dof values of the current cell and
* sums them into the vector @p dst. The function also applies constraints
* during the write operation. The functionality is hence similar to the
- * function ConstraintMatrix::distribute_local_to_global. If vectorization
+ * function AffineConstraints::distribute_local_to_global. If vectorization
* is enabled, the DoF values for several cells are used.
*
* If this class was constructed without a MatrixFree object and the
*
* Note that the two vector accesses through FEEvaluation::read_dof_values and
* FEEvaluation::distribute_local_to_global resolve constraints on the fly,
- * based on the ConstraintMatrix object specified at the MatrixFree::reinit()
+ * based on the AffineConstraints object specified at the MatrixFree::reinit()
* call. In case the values in the degrees of freedom are of interest (usually
* only the values in quadrature points are necessary), these can be accessed
* through FEEvaluation::get_dof_value(i), where i is the index of the basis
* vectors that come from different time steps, it is mandatory that all
* FEEvaluation objects share the same MatrixFree object. This is because the
* way cells are looped by MatrixFree::cell_loop() can be different for
- * different DoFHandler or ConstraintMatrix arguments. More precisely, even
+ * different DoFHandler or AffineConstraints arguments. More precisely, even
* though the layout is going to be the same in serial, there is no guarantee
* about the ordering for different DoFHandler/Constraints in the MPI
* case. The reason is that the algorithm detects cells that need data
* with hanging node constraints connects to more neighbors than a FE_DGQ
* element, for instance, and cells which need data exchange are put in
* different positions inside the cell loop. Of course, if the exact same
- * DoFHandler, ConstraintMatrix, and options (such as the setting for thread
+ * DoFHandler, AffineConstraints, and options (such as the setting for thread
* parallelism) are set, then the order is going to be the same because the
* algorithm is deterministic.
*
* @param matrix_free Data object that contains all data
*
* @param dof_no If matrix_free was set up with multiple DoFHandler
- * objects, this parameter selects to which DoFHandler/ConstraintMatrix pair
+ * objects, this parameter selects to which DoFHandler/AffineConstraints pair
* the given evaluator should be attached to.
*
* @param quad_no If matrix_free was set up with multiple Quadrature
* desired, it must be multiplied by -1.
*
* @param dof_no If matrix_free was set up with multiple DoFHandler
- * objects, this parameter selects to which DoFHandler/ConstraintMatrix pair
+ * objects, this parameter selects to which DoFHandler/AffineConstraints pair
* the given evaluator should be attached to.
*
* @param quad_no If matrix_free was set up with multiple Quadrature
*
* <h4>Selective use of blocks in MatrixFree</h4>
*
- * MatrixFree allows to use several DoFHandler/ConstraintMatrix combinations
+ * MatrixFree allows to use several DoFHandler/AffineConstraints combinations
* by passing a std::vector with pointers to the respective objects into
* the MatrixFree::reinit function. This class supports to select only some
* of the blocks in the underlying MatrixFree object by optional integer
* system subject to zero Dirichlet boundary conditions is solved that is
* then added to the initial guess. This setup can be realized by using a
* vector of two pointers pointing to the same DoFHandler object and a
- * vector of two pointers to the two ConstraintMatrix objects. If the first
+ * vector of two pointers to the two AffineConstraints objects. If the first
* constraint matrix is the one including the zero Dirichlet constraints,
* one would give a std::vector<unsigned int>(1, 0) to the initialize()
* function, i.e., a vector of length 1 that selects exactly the first
*
* For systems of PDEs where the different blocks of MatrixFree are
* associated with different physical components of the equations, adding
- * another block with a different ConstraintMatrix argument solely for the
+ * another block with a different AffineConstraints argument solely for the
* purpose of boundary conditions might lead to cumbersome index
* handling. Instead, one could set up a second MatrixFree instance with the
* different constraint matrix but the same interpretation of blocks, and
* The optional selection vector allows to choose only some components
* from the underlying MatrixFree object, e.g. just a single one. The
* entry @p selected_row_blocks[i] in the vector chooses the DoFHandler
- * and ConstraintMatrix object that was given as the
+ * and AffineConstraints object that was given as the
* @p selected_row_blocks[i]-th argument to the MatrixFree::reinit() call.
* Different arguments for rows and columns also make it possible to
* select non-diagonal blocks or rectangular blocks. If the row vector is
* The optional selection vector allows to choose only some components
* from the underlying MatrixFree object, e.g. just a single one. The
* entry @p selected_row_blocks[i] in the vector chooses the DoFHandler
- * and ConstraintMatrix object that was given as the
+ * and AffineConstraints object that was given as the
* @p selected_row_blocks[i]-th argument to the MatrixFree::reinit() call.
* Since a multigrid operator is always associated to inverting a matrix
* and thus represents a diagonal block, the same vector for rows and
* The optional selection vector allows to choose only some components
* from the underlying MatrixFree object, e.g. just a single one. The
* entry @p selected_row_blocks[i] in the vector chooses the DoFHandler
- * and ConstraintMatrix object that was given as the
+ * and AffineConstraints object that was given as the
* @p selected_row_blocks[i]-th argument to the MatrixFree::reinit() call.
* Since a multigrid operator is always associated to inverting a matrix
* and thus represents a diagonal block, the same vector for rows and
projects / dealii.git / commitdiff