void
PointValueEvaluation<dim>::
operator () (const DoFHandler<dim> &dof_handler,
- const Vector<double> &solution) const
+ const Vector<double> &solution) const
{
- // First allocate a variable that
- // will hold the point
- // value. Initialize it with a
- // value that is clearly bogus,
- // so that if we fail to set it
- // to a reasonable value, we will
- // note at once. This may not be
- // necessary in a function as
- // small as this one, since we
- // can easily see all possible
- // paths of execution here, but
- // it proved to be helpful for
- // more complex cases, and so we
- // employ this strategy here as
- // well.
+ // First allocate a variable that will hold the point value. Initialize
+ // it with a value that is clearly bogus, so that if we fail to set it
+ // to a reasonable value, we will note at once. This may not be
+ // necessary in a function as small as this one, since we can easily see
+ // all possible paths of execution here, but it proved to be helpful for
+ // more complex cases, and so we employ this strategy here as well.
double point_value = 1e20;
- // Then loop over all cells and
- // all their vertices, and check
- // whether a vertex matches the
- // evaluation point. If this is
- // the case, then extract the
- // point value, set a flag that
- // we have found the point of
+ // Then loop over all cells and all their vertices, and check whether a
+ // vertex matches the evaluation point. If this is the case, then
+ // extract the point value, set a flag that we have found the point of
// interest, and exit the loop.
typename DoFHandler<dim>::active_cell_iterator
cell = dof_handler.begin_active(),
void
PointXDerivativeEvaluation<dim>::
operator () (const DoFHandler<dim> &dof_handler,
- const Vector<double> &solution) const
+ const Vector<double> &solution) const
{
- // This time initialize the
- // return value with something
- // useful, since we will have to
- // add up a number of
- // contributions and take the
- // mean value afterwards...
+ // This time initialize the return value with something useful, since we
+ // will have to add up a number of contributions and take the mean value
+ // afterwards...
double point_derivative = 0;
- // ...then have some objects of
- // which the meaning wil become
- // clear below...
+ // ...then have some objects of which the meaning wil become clear
+ // below...
QTrapez<dim> vertex_quadrature;
FEValues<dim> fe_values (dof_handler.get_fe(),
vertex_quadrature,
};
- // And then we also have to define
- // these respective functions, of
- // course. Given our discussion in
- // the introduction of how the
- // solution should look like, the
- // following computations should be
- // straightforward:
+ // And then we also have to define these respective functions, of
+ // course. Given our discussion in the introduction of how the solution
+ // should look like, the following computations should be straightforward:
template <int dim>
- double RightHandSide<dim>::value (const Point<dim> & /*p*/,
+ double RightHandSide<dim>::value (const Point<dim> &/*p*/,
const unsigned int /*component*/) const
{
return 0;
// @sect5{Private member variables}
- // Next, we have a few member
- // variables. In particular,
- // these are (i) a reference to
- // the parameter object (owned by
- // the main function of this
- // program, and passed to the
- // constructor of this class),
- // (ii) an object describing the
- // material parameters for the
- // number of energy groups
- // requested in the input file,
- // and (iii) the finite element
- // to be used by all energy
- // groups:
+ // Next, we have a few member variables. In particular, these are (i) a
+ // reference to the parameter object (owned by the main function of this
+ // program, and passed to the constructor of this class), (ii) an object
+ // describing the material parameters for the number of energy groups
+ // requested in the input file, and (iii) the finite element to be used by
+ // all energy groups:
- const Parameters ¶meters;
+ const Parameters ¶meters;
const MaterialData material_data;
FE_Q<dim> fe;
- // The constructor takes the
- // ParameterHandler object and stores
- // it in a reference. It also
- // initializes the DoF-Handler and
- // the finite element system, which
- // consists of two copies of the
- // scalar Q1 field, one for $v$ and
- // one for $w$:
+ // The constructor takes the ParameterHandler object and stores it in a
+ // reference. It also initializes the DoF-Handler and the finite element
+ // system, which consists of two copies of the scalar Q1 field, one for $v$
+ // and one for $w$:
template <int dim>
- UltrasoundProblem<dim>::UltrasoundProblem (ParameterHandler ¶m)
+ UltrasoundProblem<dim>::UltrasoundProblem (ParameterHandler ¶m)
:
prm(param),
dof_handler(triangulation),
EulerEquations<dim>::Postprocessor::
compute_derived_quantities_vector (const std::vector<Vector<double> > &uh,
const std::vector<std::vector<Tensor<1,dim> > > &duh,
- const std::vector<std::vector<Tensor<2,dim> > > & /*dduh*/,
- const std::vector<Point<dim> > & /*normals*/,
- const std::vector<Point<dim> > & /*evaluation_points*/,
+ const std::vector<std::vector<Tensor<2,dim> > > &/*dduh*/,
+ const std::vector<Point<dim> > &/*normals*/,
+ const std::vector<Point<dim> > &/*evaluation_points*/,
std::vector<Vector<double> > &computed_quantities) const
{
- // At the beginning of the function, let us
- // make sure that all variables have the
- // correct sizes, so that we can access
- // individual vector elements without
- // having to wonder whether we might read
- // or write invalid elements; we also check
- // that the <code>duh</code> vector only
- // contains data if we really need it (the
- // system knows about this because we say
- // so in the
- // <code>get_needed_update_flags()</code>
- // function below). For the inner vectors,
- // we check that at least the first element
- // of the outer vector has the correct
- // inner size:
+ // At the beginning of the function, let us make sure that all variables
+ // have the correct sizes, so that we can access individual vector
+ // elements without having to wonder whether we might read or write
+ // invalid elements; we also check that the <code>duh</code> vector only
+ // contains data if we really need it (the system knows about this because
+ // we say so in the <code>get_needed_update_flags()</code> function
+ // below). For the inner vectors, we check that at least the first element
+ // of the outer vector has the correct inner size:
const unsigned int n_quadrature_points = uh.size();
if (do_schlieren_plot == true)
void clear();
- void reinit (const MGDoFHandler<dim> &dof_handler,
+ void reinit (const DoFHandler<dim> &dof_handler,
- const ConstraintMatrix &constraints,
+ const ConstraintMatrix &constraints,
- const unsigned int level = numbers::invalid_unsigned_int);
+ const unsigned int level = numbers::invalid_unsigned_int);
unsigned int m () const;
unsigned int n () const;
// @sect4{Initialization}
- // Once we have created the multi-grid
- // dof_handler and the constraints, we can
- // call the reinit function for each level
- // of the multi-grid routine (and the
- // active cells). The main purpose of the
- // reinit function is to setup the <code>
- // MatrixFree </code> instance for the
- // problem. Also, the coefficient is
- // evaluated. For this, we need to activate
- // the update flag in the AdditionalData
- // field of MatrixFree that enables the
- // storage of quadrature point coordinates
- // in real space (by default, it only
- // caches data for gradients (inverse
- // transposed Jacobians) and JxW
- // values). Note that if we call the reinit
- // function without specifying the level
- // (i.e., giving <code>level =
- // numbers::invalid_unsigned_int</code>),
- // we have told the class to loop over the
- // active cells.
+ // Once we have created the multi-grid dof_handler and the constraints, we
+ // can call the reinit function for each level of the multi-grid routine
+ // (and the active cells). The main purpose of the reinit function is to
+ // setup the <code> MatrixFree </code> instance for the problem. Also, the
+ // coefficient is evaluated. For this, we need to activate the update flag
+ // in the AdditionalData field of MatrixFree that enables the storage of
+ // quadrature point coordinates in real space (by default, it only caches
+ // data for gradients (inverse transposed Jacobians) and JxW values). Note
+ // that if we call the reinit function without specifying the level (i.e.,
+ // giving <code>level = numbers::invalid_unsigned_int</code>), we have told
+ // the class to loop over the active cells.
//
- // We also set one option regarding
- // task parallelism. We choose to
- // use the @p partition_color
- // strategy, which is based on
- // subdivision of cells into
- // partitions where cells in
- // partition $k$ (or, more
- // precisely, the degrees of
- // freedom on these cells) only
- // interact with cells in
- // partitions $k-1$, $k$, and
- // $k+1$. Within each partition,
- // cells are colored in such a way
- // that cells with the same color
- // do not share degrees of freedom
- // and can, therefore, be worked on
- // at the same time without
- // interference. This determines a
- // task dependency graph that is
- // scheduled by the Intel Threading
- // Building Blocks library. Another
- // option would be the strategy @p
- // partition_partition, which
- // performs better when the grid is
- // more unstructured. We could also
- // manually set the size of chunks
- // that form one task in the
- // scheduling process by setting @p
- // tasks_block_size, but the
- // default strategy to let the
- // function decide works well
- // already.
+ // We also set one option regarding task parallelism. We choose to use the
+ // @p partition_color strategy, which is based on subdivision of cells into
+ // partitions where cells in partition $k$ (or, more precisely, the degrees
+ // of freedom on these cells) only interact with cells in partitions $k-1$,
+ // $k$, and $k+1$. Within each partition, cells are colored in such a way
+ // that cells with the same color do not share degrees of freedom and can,
+ // therefore, be worked on at the same time without interference. This
+ // determines a task dependency graph that is scheduled by the Intel
+ // Threading Building Blocks library. Another option would be the strategy
+ // @p partition_partition, which performs better when the grid is more
+ // unstructured. We could also manually set the size of chunks that form one
+ // task in the scheduling process by setting @p tasks_block_size, but the
+ // default strategy to let the function decide works well already.
//
- // To initialize the coefficient,
- // we directly give it the
- // Coefficient class defined above
- // and then select the method
- // <code>coefficient_function.value</code>
- // with vectorized number (which
- // the compiler can deduce from the
- // point data type). The use of the
- // FEEvaluation class (and its
- // template arguments) will be
- // explained below.
+ // To initialize the coefficient, we directly give it the Coefficient class
+ // defined above and then select the method
+ // <code>coefficient_function.value</code> with vectorized number (which the
+ // compiler can deduce from the point data type). The use of the
+ // FEEvaluation class (and its template arguments) will be explained below.
template <int dim, int fe_degree, typename number>
void
- LaplaceOperator<dim,fe_degree,number>::reinit (const MGDoFHandler<dim> &dof_handler,
+ LaplaceOperator<dim,fe_degree,number>::reinit (const DoFHandler<dim> &dof_handler,
- const ConstraintMatrix &constraints,
+ const ConstraintMatrix &constraints,
const unsigned int level)
{
typename MatrixFree<dim,number>::AdditionalData additional_data;
template <int dim>
void
GradientEstimation::estimate (const DoFHandler<dim> &dof_handler,
- const Vector<double> &solution,
+ const Vector<double> &solution,
Vector<float> &error_per_cell)
{
- // Before starting with the work,
- // we check that the vector into
- // which the results are written,
- // has the right size. It is a
- // common error that such
- // parameters have the wrong size,
- // but the resulting damage by not
- // catching these errors are very
- // subtle as they are usually
- // corruption of data somewhere in
- // memory. Often, the problems
- // emerging from this are not
- // reproducible, and we found that
- // it is well worth the effort to
+ // Before starting with the work, we check that the vector into which the
+ // results are written, has the right size. It is a common error that such
+ // parameters have the wrong size, but the resulting damage by not
+ // catching these errors are very subtle as they are usually corruption of
+ // data somewhere in memory. Often, the problems emerging from this are
+ // not reproducible, and we found that it is well worth the effort to
// check for such things.
Assert (error_per_cell.size() == dof_handler.get_tria().n_active_cells(),
ExcInvalidVectorLength (error_per_cell.size(),
/**
* Name of the exception and call sequence.
*/
- const char *exc;
+ const char *exc;
/**
- * A backtrace to the position
- * where the problem happened, if
- * the system supports this.
+ * A backtrace to the position where the problem happened, if the
+ * system supports this.
*/
char **stacktrace;
//---------------------------------------------------------------------------
// $Id$
//
--// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 by the deal.II authors
++// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
//---------------------------------------------------------------------------
// $Id$
//
--// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011, 2012 by the deal.II authors
++// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
enum UpdateFlags
{
//! No update
- update_default = 0,
+ update_default = 0,
//! Shape function values
/**
- * Compute the values of the
- * shape functions at the
- * quadrature points on the
- * real space cell. For the
- * usual Lagrange elements,
- * these values are equal to
- * the values of the shape
- * functions at the quadrature
- * points on the unit cell, but
- * they are different for more
- * complicated elements, such
- * as FE_RaviartThomas
- * elements.
+ * Compute the values of the shape functions at the quadrature points on
+ * the real space cell. For the usual Lagrange elements, these values are
+ * equal to the values of the shape functions at the quadrature points on
+ * the unit cell, but they are different for more complicated elements,
+ * such as FE_RaviartThomas elements.
*/
- update_values = 0x0001,
+ update_values = 0x0001,
//! Shape function gradients
/**
- * Compute the gradients of the
- * shape functions in
- * coordinates of the real
- * cell.
+ * Compute the gradients of the shape functions in coordinates of the
+ * real cell.
*/
- update_gradients = 0x0002,
+ update_gradients = 0x0002,
//! Second derivatives of shape functions
/**
- * Compute the second
- * derivatives of the shape
- * functions in coordinates of
- * the real cell.
+ * Compute the second derivatives of the shape functions in coordinates
+ * of the real cell.
*/
- update_hessians = 0x0004,
+ update_hessians = 0x0004,
+ //! 3rd derivatives of shape functions
+ /**
+ * Compute the 3rd
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_3rd_derivatives = 0x0008,
+ //! 4th derivatives of shape functions
+ /**
+ * Compute the 4th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_4th_derivatives = 0x0010,
+ //! 5th derivatives of shape functions
+ /**
+ * Compute the 5th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_5th_derivatives = 0x0020,
+ //! 6th derivatives of shape functions
+ /**
+ * Compute the 6th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_6th_derivatives = 0x0040,
+ //! 7th derivatives of shape functions
+ /**
+ * Compute the 7th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_7th_derivatives = 0x0080,
+ //! 8th derivatives of shape functions
+ /**
+ * Compute the 8th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_8th_derivatives = 0x0100,
+ //! 9th derivatives of shape functions
+ /**
+ * Compute the 9th
+ * derivatives of the shape
+ * functions in coordinates of
+ * the real cell.
+ */
+ update_9th_derivatives = 0x0200,
//! Outer normal vector, not normalized
/**
- * Vector product of tangential
- * vectors, yielding a normal
- * vector with a length
- * corresponding to the surface
- * element; may be more
- * efficient than computing
- * both.
+ * Vector product of tangential vectors, yielding a normal vector with
+ * a length corresponding to the surface element; may be more efficient
+ * than computing both.
*/
- update_boundary_forms = 0x0008,
+ update_boundary_forms = 0x0400,
//! Transformed quadrature points
/**
- * Compute the quadrature
- * points transformed into real
- * cell coordinates.
+ * Compute the quadrature points transformed into real cell coordinates.
*/
- update_quadrature_points = 0x0010,
+ update_quadrature_points = 0x0800,
//! Transformed quadrature weights
/**
- * Compute the quadrature
- * weights on the real cell,
- * i.e. the weights of the
- * quadrature rule multiplied
- * with the determinant of the
- * Jacoian of the
- * transformation from
- * reference to realcell.
+ * Compute the quadrature weights on the real cell, i.e. the weights
+ * of the quadrature rule multiplied with the determinant of the Jacoian
+ * of the transformation from reference to realcell.
*/
- update_JxW_values = 0x0020,
+ update_JxW_values = 0x1000,
//! Normal vectors
/**
- * Compute the normal vectors,
- * either for a face or for a
- * cell of codimension
- * one. Setting this flag for
- * any other object will raise
+ * Compute the normal vectors, either for a face or for a cell of
+ * codimension one. Setting this flag for any other object will raise
* an error.
*/
- update_normal_vectors = 0x0040,
+ update_normal_vectors = 0x2000,
/**
* @deprecated Use #update_normal_vectors
*/
/**
* @deprecated Use #update_normal_vectors
*/
- update_cell_normal_vectors = update_normal_vectors,
+ update_cell_normal_vectors = update_normal_vectors,
//! Volume element
/**
- * Compute the Jacobian of the
- * transformation from the
- * reference cell to the real
- * cell.
+ * Compute the Jacobian of the transformation from the reference cell
+ * to the real cell.
*/
- update_jacobians = 0x0080,
+ update_jacobians = 0x4000,
//! Gradient of volume element
/**
- * Compute the dervatives of
- * the Jacobian of the
- * transformation.
+ * Compute the dervatives of the Jacobian of the transformation.
*/
- update_jacobian_grads = 0x0100,
+ update_jacobian_grads = 0x8000,
//! Volume element
/**
- * Compute the inverse
- * Jacobian of the
- * transformation from the
- * reference cell to the real
- * cell.
+ * Compute the inverse Jacobian of the transformation from the reference
+ * cell to the real cell.
*/
- update_inverse_jacobians = 0x0200,
+ update_inverse_jacobians = 0x10000,
//! Covariant transformation
/**
- * Compute all values the
- * Mapping needs to perform a
- * contravariant transformation of
- * vectors. For special
- * mappings like
- * MappingCartesian this may be
- * simpler than
- * #update_inverse_jacobians.
+ * Compute all values the Mapping needs to perform a contravariant
+ * transformation of vectors. For special mappings like MappingCartesian
+ * this may be simpler than #update_inverse_jacobians.
*/
- update_covariant_transformation = 0x0400,
+ update_covariant_transformation = 0x20000,
//! Contravariant transformation
/**
- * Compute all values the
- * Mapping needs to perform a
- * contravariant transformation of
- * vectors. For special
- * mappings like
- * MappingCartesian this may be
- * simpler than
- * #update_jacobians.
+ * Compute all values the Mapping needs to perform a contravariant
+ * transformation of vectors. For special mappings like MappingCartesian
+ * this may be simpler than #update_jacobians.
*/
- update_contravariant_transformation = 0x0800,
+ update_contravariant_transformation = 0x40000,
//! Shape function values of transformation
/**
- * Compute the shape function
- * values of the transformation
- * defined by the Mapping.
+ * Compute the shape function values of the transformation defined by
+ * the Mapping.
*/
- update_transformation_values = 0x1000,
+ update_transformation_values = 0x80000,
//! Shape function gradients of transformation
/**
- * Compute the shape function
- * gradients of the
- * transformation defined by
- * the Mapping.
+ * Compute the shape function gradients of the transformation defined
+ * by the Mapping.
*/
- update_transformation_gradients = 0x2000,
+ update_transformation_gradients = 0x100000,
//! Determinant of the Jacobian
/**
- * Compute the volume element
- * in each quadrature point.
+ * Compute the volume element in each quadrature point.
*/
- update_volume_elements = 0x4000,
+ update_volume_elements = 0x200000,
/**
- * Update the location of the
- * mapped generalized support
- * points of the element.
+ * Update the location of the mapped generalized support points of
+ * the element.
*/
- update_support_points = 0x10000,
+ update_support_points = 0x400000,
/**
- * Update the Jacobian of the
- * mapping in generalized
- * support points.
+ * Update the Jacobian of the mapping in generalized support points.
*/
- update_support_jacobians = 0x20000,
+ update_support_jacobians = 0x800000,
/**
- * Update the inverse Jacobian
- * of the mapping in
- * generalized support points.
+ * Update the inverse Jacobian of the mapping in generalized support
+ * points.
*/
- update_support_inverse_jacobians = 0x40000,
+ update_support_inverse_jacobians = 0x1000000,
/**
- * @deprecated Update
- * quadrature points
+ * @deprecated Update quadrature points
*/
update_q_points = update_quadrature_points,
/**
explicit SparseMatrix (const SparsityPattern &sparsity);
/**
- * Copy constructor: initialize
- * the matrix with the identity
- * matrix. This constructor will
- * throw an exception if the
- * sizes of the sparsity pattern
- * and the identity matrix do not
- * coincide, or if the sparsity
- * pattern does not provide for
- * nonzero entries on the entire
- * diagonal.
+ * Copy constructor: initialize the matrix with the identity matrix. This
+ * constructor will throw an exception if the sizes of the sparsity pattern
+ * and the identity matrix do not coincide, or if the sparsity pattern does
+ * not provide for nonzero entries on the entire diagonal.
*/
SparseMatrix (const SparsityPattern &sparsity,
- const IdentityMatrix &id);
+ const IdentityMatrix &id);
/**
- * Destructor. Free all memory, but do not
- * release the memory of the sparsity
- * structure.
+ * Destructor. Free all memory, but do not release the memory of the
+ * sparsity structure.
*/
virtual ~SparseMatrix ();
SparseMatrix<number> &operator = (const SparseMatrix<number> &);
/**
- * Copy operator: initialize
- * the matrix with the identity
- * matrix. This operator will
- * throw an exception if the
- * sizes of the sparsity pattern
- * and the identity matrix do not
- * coincide, or if the sparsity
- * pattern does not provide for
- * nonzero entries on the entire
- * diagonal.
+ * Copy operator: initialize the matrix with the identity matrix. This
+ * operator will throw an exception if the sizes of the sparsity pattern and
+ * the identity matrix do not coincide, or if the sparsity pattern does not
+ * provide for nonzero entries on the entire diagonal.
*/
SparseMatrix<number> &
- operator= (const IdentityMatrix &id);
+ operator= (const IdentityMatrix &id);
/**
- * This operator assigns a scalar to
- * a matrix. Since this does usually
- * not make much sense (should we set
- * all matrix entries to this value?
- * Only the nonzero entries of the
- * sparsity pattern?), this operation
- * is only allowed if the actual
- * value to be assigned is zero. This
- * operator only exists to allow for
- * the obvious notation
- * <tt>matrix=0</tt>, which sets all
- * elements of the matrix to zero,
- * but keep the sparsity pattern
+ * This operator assigns a scalar to a matrix. Since this does usually not
+ * make much sense (should we set all matrix entries to this value? Only
+ * the nonzero entries of the sparsity pattern?), this operation is only
+ * allowed if the actual value to be assigned is zero. This operator only
+ * exists to allow for the obvious notation <tt>matrix=0</tt>, which sets
+ * all elements of the matrix to zero, but keep the sparsity pattern
* previously used.
*/
SparseMatrix &operator = (const double d);
/**
* Make a copy with extra off-diagonals.
*
- * This constructs objects intended for
- * the application of the ILU(n)-method
- * or other incomplete decompositions.
- * Therefore, additional to the original
- * entry structure, space for
- * <tt>extra_off_diagonals</tt>
- * side-diagonals is provided on both
- * sides of the main diagonal.
- *
- * <tt>max_per_row</tt> is the
- * maximum number of nonzero
- * elements per row which this
- * structure is to hold. It is
- * assumed that this number is
- * sufficiently large to
- * accommodate both the elements
- * in <tt>original</tt> as well
- * as the new off-diagonal
- * elements created by this
- * constructor. You will usually
- * want to give the same number
- * as you gave for
- * <tt>original</tt> plus the
- * number of side diagonals times
- * two. You may however give a
- * larger value if you wish to
- * add further nonzero entries
- * for the decomposition based on
- * other criteria than their
- * being on side-diagonals.
- *
- * This function requires that
- * <tt>original</tt> refers to a
- * quadratic matrix structure.
- * It must be compressed. The
- * matrix structure is not
- * compressed after this function
- * finishes.
+ * This constructs objects intended for the application of the ILU(n)-method
+ * or other incomplete decompositions. Therefore, additional to the
+ * original entry structure, space for <tt>extra_off_diagonals</tt>
+ * side-diagonals is provided on both sides of the main diagonal.
+ *
+ * <tt>max_per_row</tt> is the maximum number of nonzero elements per row
+ * which this structure is to hold. It is assumed that this number is
+ * sufficiently large to accommodate both the elements in <tt>original</tt>
+ * as well as the new off-diagonal elements created by this constructor. You
+ * will usually want to give the same number as you gave for
+ * <tt>original</tt> plus the number of side diagonals times two. You may
+ * however give a larger value if you wish to add further nonzero entries
+ * for the decomposition based on other criteria than their being on
+ * side-diagonals.
+ *
+ * This function requires that <tt>original</tt> refers to a quadratic
+ * matrix structure. It must be compressed. The matrix structure is not
+ * compressed after this function finishes.
*/
- SparsityPattern (const SparsityPattern &original,
+ SparsityPattern (const SparsityPattern &original,
const unsigned int max_per_row,
const unsigned int extra_off_diagonals);
*/
UpdateFlags
compute_update_flags (const UpdateFlags update_flags,
- const std::vector<dealii::hp::QCollection<1> > &quad) const;
+ const std::vector<dealii::hp::QCollection<1> > &quad) const;
/**
- * Returns the type of a given cell as
- * detected during initialization.
+ * Returns the type of a given cell as detected during initialization.
*/
CellType get_cell_type (const unsigned int cell_chunk_no) const;
//---------------------------------------------------------------------------
// $Id$
//
--// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012 by the deal.II authors
++// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
template <int dim, int spacedim>
void
- make_boundary_list (const MGDoFHandler<dim,spacedim> &mg_dof,
+ make_boundary_list (const DoFHandler<dim,spacedim> &mg_dof,
const typename FunctionMap<dim>::type &function_map,
- std::vector<std::set<unsigned int> > &boundary_indices,
+ std::vector<std::set<unsigned int> > &boundary_indices,
const ComponentMask &component_mask = ComponentMask());
/**
*/
template <int dim, int spacedim>
void
- extract_inner_interface_dofs (const MGDoFHandler<dim,spacedim> &mg_dof_handler,
+ extract_inner_interface_dofs (const DoFHandler<dim,spacedim> &mg_dof_handler,
- std::vector<std::vector<bool> > &interface_dofs,
- std::vector<std::vector<bool> > &boundary_interface_dofs);
+ std::vector<std::vector<bool> > &interface_dofs,
+ std::vector<std::vector<bool> > &boundary_interface_dofs);
/**
* Does the same as the function above,
*/
template <int dim, int spacedim>
void
- extract_inner_interface_dofs (const MGDoFHandler<dim,spacedim> &mg_dof_handler,
+ extract_inner_interface_dofs (const DoFHandler<dim,spacedim> &mg_dof_handler,
- std::vector<std::vector<bool> > &interface_dofs);
+ std::vector<std::vector<bool> > &interface_dofs);
template <int dim, int spacedim>
void
- extract_non_interface_dofs (const MGDoFHandler<dim,spacedim> &mg_dof_handler,
+ extract_non_interface_dofs (const DoFHandler<dim,spacedim> &mg_dof_handler,
- std::vector<std::set<unsigned int> > &non_interface_dofs);
+ std::vector<std::set<unsigned int> > &non_interface_dofs);
}
/* @} */
// $Id$
// Version: $name$
//
--// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by the deal.II authors
++// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
void
- make_hp_hanging_node_constraints (const dealii::hp::DoFHandler<1> & /*dof_handler*/,
- ConstraintMatrix & /*constraints*/)
+ make_hp_hanging_node_constraints (const dealii::hp::DoFHandler<1> &/*dof_handler*/,
+ ConstraintMatrix &/*constraints*/)
{
- // we may have to compute
- // constraints for
- // vertices. gotta think about
+ // we may have to compute constraints for vertices. gotta think about
// that a bit more
- //TODO[WB]: think about what to do here...
+
+ //TODO[WB]: think about what to do here...
}
void
- make_oldstyle_hanging_node_constraints (const dealii::hp::DoFHandler<1> & /*dof_handler*/,
- ConstraintMatrix & /*constraints*/,
+ make_oldstyle_hanging_node_constraints (const dealii::hp::DoFHandler<1> &/*dof_handler*/,
+ ConstraintMatrix &/*constraints*/,
dealii::internal::int2type<1>)
{
- // we may have to compute
- // constraints for
- // vertices. gotta think about
+ // we may have to compute constraints for vertices. gotta think about
// that a bit more
- //TODO[WB]: think about what to do here...
+
+ //TODO[WB]: think about what to do here...
}
// $Id$
// Version: $Name$
//
--// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012 by the deal.II authors
++// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
--// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by the deal.II authors
++// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
//---------------------------------------------------------------------------
// $Id$
//
--// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 by the deal.II authors
++// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
# in the report with it. for a branch, prefix everything
# with x-branch-name/ so that tests run from the branch will show up
# in different folders on the webpage.
-WORKDIR = x-branch_parallel_mg/$(notdir $(shell pwd))
-
+WORKDIR = x-branch-higher-derivatives/$(notdir $(shell pwd))
-
projects / dealii-svn.git / commitdiff