AlignedVector ();
/**
- * Sets the vector size to the given size and initializes all elements with
+ * Set the vector size to the given size and initializes all elements with
* T().
*
* @dealiiOperationIsMultithreaded
void push_back (const T in_data);
/**
- * Returns the last element of the vector (read and write access).
+ * Return the last element of the vector (read and write access).
*/
reference back ();
/**
- * Returns the last element of the vector (read-only access).
+ * Return the last element of the vector (read-only access).
*/
const_reference back () const;
void swap (AlignedVector<T> &vec);
/**
- * Returns whether the vector is empty, i.e., its size is zero.
+ * Return whether the vector is empty, i.e., its size is zero.
*/
bool empty () const;
/**
- * Returns the size of the vector.
+ * Return the size of the vector.
*/
size_type size () const;
/**
- * Returns the capacity of the vector, i.e., the size this vector can hold
+ * Return the capacity of the vector, i.e., the size this vector can hold
* without reallocation. Note that capacity() >= size().
*/
size_type capacity () const;
const_reference operator [] (const size_type index) const;
/**
- * Returns a read and write pointer to the beginning of the data array.
+ * Return a read and write pointer to the beginning of the data array.
*/
iterator begin ();
/**
- * Returns a read and write pointer to the end of the data array.
+ * Return a read and write pointer to the end of the data array.
*/
iterator end ();
/**
- * Returns a read-only pointer to the beginning of the data array.
+ * Return a read-only pointer to the beginning of the data array.
*/
const_iterator begin () const;
/**
- * Returns a read-only pointer to the end of the data array.
+ * Return a read-only pointer to the end of the data array.
*/
const_iterator end () const;
/**
- * Returns the memory consumption of the allocated memory in this class. If
+ * Return the memory consumption of the allocated memory in this class. If
* the underlying type @p T allocates memory by itself, this memory is not
* counted.
*/
* Return the gradient of the specified component of the function at the
* given point.
*
- * Computes numerical difference quotients using the preset
+ * Compute numerical difference quotients using the preset
* #DifferenceFormula.
*/
virtual Tensor<1,dim> gradient (const Point<dim> &p,
/**
* Return the gradient of all components of the function at the given point.
*
- * Computes numerical difference quotients using the preset
+ * Compute numerical difference quotients using the preset
* #DifferenceFormula.
*/
virtual void vector_gradient (const Point<dim> &p,
* already has the right size, i.e. the same size as the <tt>points</tt>
* array.
*
- * Computes numerical difference quotients using the preset
+ * Compute numerical difference quotients using the preset
* #DifferenceFormula.
*/
virtual void gradient_list (const std::vector<Point<dim> > &points,
* The outer loop over <tt>gradients</tt> is over the points in the list,
* the inner loop over the different components of the function.
*
- * Computes numerical difference quotients using the preset
+ * Compute numerical difference quotients using the preset
* #DifferenceFormula.
*/
virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
- * Returns a #DifferenceFormula of the order <tt>ord</tt> at minimum.
+ * Return a #DifferenceFormula of the order <tt>ord</tt> at minimum.
*/
static
DifferenceFormula
{
/**
- * Returns spherical coordinates of a Cartesian point @p point.
+ * Return spherical coordinates of a Cartesian point @p point.
* The returned array is filled with radius, azimuth angle $\in [0,2 \pi)$
* and polar/inclination angle $ \in [0,\pi]$ (ommited in 2D).
*/
project_to_unit_cell (const Point<dim> &p);
/**
- * Returns the infinity norm of the vector between a given point @p p
+ * Return the infinity norm of the vector between a given point @p p
* outside the unit cell to the closest unit cell boundary. For points
* inside the cell, this is defined as zero.
*/
void print(StreamType &out) const;
/**
- * Writes the IndexSet into a text based file format, that can be read in
+ * Write the IndexSet into a text based file format, that can be read in
* again using the read() function.
*/
void write(std::ostream &out) const;
/**
- * Constructs the IndexSet from a text based representation given by the
+ * Construct the IndexSet from a text based representation given by the
* stream @p in written by the write() function.
*/
void read(std::istream &in);
/**
- * Writes the IndexSet into a binary, compact representation, that can be
+ * Write the IndexSet into a binary, compact representation, that can be
* read in again using the block_read() function.
*/
void block_write(std::ostream &out) const;
/**
- * Constructs the IndexSet from a binary representation given by the stream
+ * Construct the IndexSet from a binary representation given by the stream
* @p in written by the write_block() function.
*/
void block_read(std::istream &in);
* can be set via <tt>LogStream::Prefix p("loopname");</tt>. The destructor of
* the prefix will pop the prefix text from the stack.
*
- * Writes via the <tt><<</tt> operator, <tt> deallog << "This is a log
+ * Write via the <tt><<</tt> operator, <tt> deallog << "This is a log
* notice";</tt> will be buffered thread locally until a <tt>std::flush</tt>
* or <tt>std::endl</tt> is encountered, which will trigger a writeout to the
* console and, if set up, the log file.
};
/**
- * Returns sum, average, minimum, maximum, processor id of minimum and
+ * Return sum, average, minimum, maximum, processor id of minimum and
* maximum as a collective operation of on the given MPI
* @ref GlossMPICommunicator "communicator"
* @p mpi_communicator. Each processor's value is given in @p my_value and
static unsigned int n_cores ();
/**
- * Returns the number of threads to use. This is initially set to the number
+ * Return the number of threads to use. This is initially set to the number
* of cores the system has (see n_cores()) but can be further restricted by
* set_thread_limit() and the environment variable DEAL_II_NUM_THREADS.
*/
static void set_thread_limit (const unsigned int max_threads = numbers::invalid_unsigned_int);
/**
- * Returns if the TBB is running using a single thread either because of
+ * Return if the TBB is running using a single thread either because of
* thread affinity or because it is set via a call to set_thread_limit. This
* is used in the PETScWrappers to avoid using the interface that is not
* thread-safe.
};
/**
- * Returns pointer to the correct derived class based on description.
+ * Return pointer to the correct derived class based on description.
*/
PatternBase *pattern_factory (const std::string &description);
const MPI_Comm &communicator);
/**
- * Sets the locally owned indices. Used in the constructor.
+ * Set the locally owned indices. Used in the constructor.
*/
void set_owned_indices (const IndexSet &locally_owned_indices);
void set_ghost_indices (const IndexSet &ghost_indices);
/**
- * Returns the global size.
+ * Return the global size.
*/
types::global_dof_index size() const;
/**
- * Returns the local size, i.e. local_range().second minus
+ * Return the local size, i.e. local_range().second minus
* local_range().first.
*/
unsigned int local_size() const;
/**
- * Returns an IndexSet representation of the local range. This class
+ * Return an IndexSet representation of the local range. This class
* only supports contiguous local ranges, so the IndexSet actually only
* consists of one single range of data, and is equivalent to the result
* of local_range().
const IndexSet &locally_owned_range() const;
/**
- * Returns the local range. The returned pair consists of the index of
+ * Return the local range. The returned pair consists of the index of
* the first element and the index of the element one past the last
* locally owned one.
*/
local_range() const;
/**
- * Returns true if the given global index is in the local range of this
+ * Return true if the given global index is in the local range of this
* processor.
*/
bool in_local_range (const types::global_dof_index global_index) const;
/**
- * Returns the local index corresponding to the given global index. If
+ * Return the local index corresponding to the given global index. If
* the given global index is neither locally owned nor a ghost, an
* exception is thrown.
*
global_to_local (const types::global_dof_index global_index) const;
/**
- * Returns the global index corresponding to the given local index.
+ * Return the global index corresponding to the given local index.
*
* Note that the local index for locally owned indices is between 0 and
* local_size()-1, and the local index for ghosts is between
local_to_global (const unsigned int local_index) const;
/**
- * Returns whether the given global index is a ghost index on the
+ * Return whether the given global index is a ghost index on the
* present processor. Returns false for indices that are owned locally
* and for indices not present at all.
*/
bool is_ghost_entry (const types::global_dof_index global_index) const;
/**
- * Returns an IndexSet representation of all ghost indices.
+ * Return an IndexSet representation of all ghost indices.
*/
const IndexSet &ghost_indices() const;
/**
- * Returns the number of ghost indices. Same as
+ * Return the number of ghost indices. Same as
* ghost_indices().n_elements(), but cached for simpler access.
*/
unsigned int n_ghost_indices() const;
/**
- * Returns a list of processors (first entry) and the number of degrees
+ * Return a list of processors (first entry) and the number of degrees
* of freedom for the individual processor on the ghost elements present
* (second entry).
*/
unsigned int n_import_indices() const;
/**
- * Returns a list of processors (first entry) and the number of degrees
+ * Return a list of processors (first entry) and the number of degrees
* of freedom for all the processors that data is obtained from (second
* entry), i.e., locally owned indices that are ghosts on other
* processors.
import_targets() const;
/**
- * Checks whether the given partitioner is compatible with the
+ * Check whether the given partitioner is compatible with the
* partitioner used for this vector. Two partitioners are compatible if
* they have the same local size and the same ghost indices. They do not
* necessarily need to be the same data field. This is a local operation
bool is_compatible (const Partitioner &part) const;
/**
- * Checks whether the given partitioner is compatible with the
+ * Check whether the given partitioner is compatible with the
* partitioner used for this vector. Two partitioners are compatible if
* they have the same local size and the same ghost indices. They do not
* necessarily need to be the same data field. As opposed to
bool is_globally_compatible (const Partitioner &part) const;
/**
- * Returns the MPI ID of the calling processor. Cached to have simple
+ * Return the MPI ID of the calling processor. Cached to have simple
* access.
*/
unsigned int this_mpi_process () const;
/**
- * Returns the total number of MPI processor participating in the given
+ * Return the total number of MPI processor participating in the given
* partitioner. Cached to have simple access.
*/
unsigned int n_mpi_processes () const;
/**
- * Returns the MPI communicator underlying the partitioner object.
+ * Return the MPI communicator underlying the partitioner object.
*/
const MPI_Comm &get_communicator() const DEAL_II_DEPRECATED;
/**
- * Returns the MPI communicator underlying the partitioner object.
+ * Return the MPI communicator underlying the partitioner object.
*/
virtual const MPI_Comm &get_mpi_communicator() const;
/**
- * Returns whether ghost indices have been explicitly added as a @p
+ * Return whether ghost indices have been explicitly added as a @p
* ghost_indices argument. Only true if a reinit call or constructor
* provided that argument.
*/
bool ghost_indices_initialized() const;
/**
- * Computes the memory consumption of this structure.
+ * Compute the memory consumption of this structure.
*/
std::size_t memory_consumption() const;
private:
/**
- * Computes the <tt>coefficients</tt> of the base class Polynomial. This
+ * Compute the <tt>coefficients</tt> of the base class Polynomial. This
* function is <tt>static</tt> to allow to be called in the constructor.
*/
static
void output_indices(StreamType &out) const;
/**
- * Sets the ordering of the polynomials. Requires
+ * Set the ordering of the polynomials. Requires
* <tt>renumber.size()==n()</tt>. Stores a copy of <tt>renumber</tt>.
*/
void set_numbering(const std::vector<unsigned int> &renumber);
/**
- * Computes the value and the first and second derivatives of each
+ * Compute the value and the first and second derivatives of each
* polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal 0 or equal n(). In the first
std::vector<Tensor<4,dim> > &fourth_derivatives) const;
/**
- * Computes the value of the <tt>i</tt>th polynomial at unit point
+ * Compute the value of the <tt>i</tt>th polynomial at unit point
* <tt>p</tt>.
*
* Consider using compute() instead.
const Point<dim> &p) const;
/**
- * Computes the <tt>order</tt>th derivative of the <tt>i</tt>th polynomial
+ * Compute the <tt>order</tt>th derivative of the <tt>i</tt>th polynomial
* at unit point <tt>p</tt>.
*
* Consider using compute() instead.
const Point<dim> &p) const;
/**
- * Computes the gradient of the <tt>i</tt>th polynomial at unit point
+ * Compute the gradient of the <tt>i</tt>th polynomial at unit point
* <tt>p</tt>.
*
* Consider using compute() instead.
const Point<dim> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th polynomial
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th polynomial
* at unit point <tt>p</tt>.
*
* Consider using compute() instead.
~PolynomialsABF ();
/**
- * Computes the value and the first and second derivatives of each Raviart-
+ * Compute the value and the first and second derivatives of each Raviart-
* Thomas polynomial at @p unit_point.
*
* The size of the vectors must either be zero or equal <tt>n()</tt>. In
std::vector<Tensor<5,dim> > &fourth_derivatives) const;
/**
- * Returns the number of ABF polynomials.
+ * Return the number of ABF polynomials.
*/
unsigned int n () const;
/**
- * Returns the degree of the ABF space, which is two less than the highest
+ * Return the degree of the ABF space, which is two less than the highest
* polynomial degree.
*/
unsigned int degree () const;
*/
PolynomialsAdini ();
/**
- * Computes the value and the first and second derivatives of each
+ * Compute the value and the first and second derivatives of each
* polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal 0 or equal n(). In the first
std::vector< Tensor<2,2> > &grad_grads) const;
/**
- * Computes the value of the <tt>i</tt>th polynomial at <tt>unit_point</tt>.
+ * Compute the value of the <tt>i</tt>th polynomial at <tt>unit_point</tt>.
*
* Consider using compute() instead.
*/
const Point<2> &p) const;
/**
- * Computes the gradient of the <tt>i</tt>th polynomial at
+ * Compute the gradient of the <tt>i</tt>th polynomial at
* <tt>unit_point</tt>.
*
* Consider using compute() instead.
Tensor<1,2> compute_grad (const unsigned int i,
const Point<2> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th polynomial
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th polynomial
* at <tt>unit_point</tt>.
*
* Consider using compute() instead.
PolynomialsBDM (const unsigned int k);
/**
- * Computes the value and the first and second derivatives of each BDM
+ * Compute the value and the first and second derivatives of each BDM
* polynomial at @p unit_point.
*
* The size of the vectors must either be zero or equal <tt>n()</tt>. In
std::vector<Tensor<5,dim> > &fourth_derivatives) const;
/**
- * Returns the number of BDM polynomials.
+ * Return the number of BDM polynomials.
*/
unsigned int n () const;
/**
- * Returns the degree of the BDM space, which is one less than the highest
+ * Return the degree of the BDM space, which is one less than the highest
* polynomial degree.
*/
unsigned int degree () const;
PolynomialsNedelec (const unsigned int k);
/**
- * Computes the value and the first and second derivatives of each Nédélec
+ * Compute the value and the first and second derivatives of each Nédélec
* polynomial at @p unit_point.
*
* The size of the vectors must either be zero or equal <tt>n()</tt>. In
std::vector<Tensor<5,dim> > &fourth_derivatives) const;
/**
- * Returns the number of Nédélec polynomials.
+ * Return the number of Nédélec polynomials.
*/
unsigned int n () const;
/**
- * Returns the degree of the Nédélec space, which is one less than the
+ * Return the degree of the Nédélec space, which is one less than the
* highest polynomial degree.
*/
unsigned int degree () const;
PolynomialsP (const unsigned int p);
/**
- * Returns the degree <tt>p</tt> of the polynomial space <tt>P_p</tt>.
+ * Return the degree <tt>p</tt> of the polynomial space <tt>P_p</tt>.
*
* Note, that this number is <tt>PolynomialSpace::degree()-1</tt>, compare
* definition in PolynomialSpace.
PolynomialsRaviartThomas (const unsigned int k);
/**
- * Computes the value and the first and second derivatives of each Raviart-
+ * Compute the value and the first and second derivatives of each Raviart-
* Thomas polynomial at @p unit_point.
*
* The size of the vectors must either be zero or equal <tt>n()</tt>. In
std::vector<Tensor<5,dim> > &fourth_derivatives) const;
/**
- * Returns the number of Raviart-Thomas polynomials.
+ * Return the number of Raviart-Thomas polynomials.
*/
unsigned int n () const;
/**
- * Returns the degree of the Raviart-Thomas space, which is one less than
+ * Return the degree of the Raviart-Thomas space, which is one less than
* the highest polynomial degree.
*/
unsigned int degree () const;
protected:
/**
- * Sets the points of the quadrature formula.
+ * Set the points of the quadrature formula.
*/
std::vector<double>
set_quadrature_points(const unsigned int n) const;
/**
- * Sets the weights of the quadrature formula.
+ * Set the weights of the quadrature formula.
*/
std::vector<double>
set_quadrature_weights(const unsigned int n) const;
/**
- * Returns the fourth-order symmetric identity tensor which maps symmetric
+ * Return the fourth-order symmetric identity tensor which maps symmetric
* second-order tensors to themselves.
*
* Note that this tensor, even though it is the identity, has a somewhat funny
void set_column_order (const std::vector<std::string> &new_order);
/**
- * Sets the <tt>precision</tt> e.g. double or float variables are written
+ * Set the <tt>precision</tt> e.g. double or float variables are written
* with. <tt>precision</tt> is the same as in calling
* <tt>out<<setprecision(precision)</tt>.
*/
const unsigned int precision);
/**
- * Sets the <tt>scientific_flag</tt>. True means scientific, false means
+ * Set the <tt>scientific_flag</tt>. True means scientific, false means
* fixed point notation.
*/
void set_scientific (const std::string &key,
const bool scientific);
/**
- * Sets the caption of the column <tt>key</tt> for tex output. You may want
+ * Set the caption of the column <tt>key</tt> for tex output. You may want
* to chose this different from <tt>key</tt>, if it contains formulas or
* similar constructs.
*/
const std::string &tex_caption);
/**
- * Sets the tex caption of the entire <tt>table</tt> for tex output.
+ * Set the tex caption of the entire <tt>table</tt> for tex output.
*/
void set_tex_table_caption (const std::string &table_caption);
/**
- * Sets the label of this <tt>table</tt> for tex output.
+ * Set the label of this <tt>table</tt> for tex output.
*/
void set_tex_table_label (const std::string &table_label);
/**
- * Sets the caption the the supercolumn <tt>superkey</tt> for tex output.
+ * Set the caption the the supercolumn <tt>superkey</tt> for tex output.
* You may want to chose this different from <tt>superkey</tt>, if it
* contains formulas or similar constructs.
*/
const std::string &tex_supercaption);
/**
- * Sets the tex output format of a column, e.g. <tt>c</tt>, <tt>r</tt>,
+ * Set the tex output format of a column, e.g. <tt>c</tt>, <tt>r</tt>,
* <tt>l</tt>, or <tt>p{3cm}</tt>. The default is <tt>c</tt>. Also if this
* function is not called for a column, the default is preset to be
* <tt>c</tt>.
void write_tex (std::ostream &file, const bool with_header=true) const;
/**
- * Clears the rows of the table, i.e. calls clear() on all the underlying
+ * Clear the rows of the table, i.e. calls clear() on all the underlying
* storage data structures.
*/
void clear ();
void unroll (Vector<OtherNumber> &result) const;
/**
- * Returns an unrolled index in the range [0,dim^rank-1] for the element of
+ * Return an unrolled index in the range [0,dim^rank-1] for the element of
* the tensor indexed by the argument to the function.
*/
static
/**
- * Returns the cross product in 2d. This is just a rotation by 90 degrees
+ * Return the cross product in 2d. This is just a rotation by 90 degrees
* clockwise to compute the outer normal from a tangential vector. This
* function is defined for all space dimensions to allow for dimension
* independent programming (e.g. within switches over the space dimension),
/**
- * Returns the cross product of 2 vectors in 3d. This function is defined for
+ * Return the cross product of 2 vectors in 3d. This function is defined for
* all space dimensions to allow for dimension independent programming (e.g.
* within switches over the space dimension), but may only be called if the
* actual dimension of the arguments is three (e.g. from the <tt>dim==3</tt>
void output_indices(std::ostream &out) const;
/**
- * Sets the ordering of the polynomials. Requires
+ * Set the ordering of the polynomials. Requires
* <tt>renumber.size()==n()</tt>. Stores a copy of <tt>renumber</tt>.
*/
void set_numbering(const std::vector<unsigned int> &renumber);
const std::vector<unsigned int> &get_numbering_inverse() const;
/**
- * Computes the value and the first and second derivatives of each tensor
+ * Compute the value and the first and second derivatives of each tensor
* product polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal 0 or equal n(). In the first
std::vector<Tensor<4,dim> > &fourth_derivatives) const;
/**
- * Computes the value of the <tt>i</tt>th tensor product polynomial at
+ * Compute the value of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
+ * Compute the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Computes the grad of the <tt>i</tt>th tensor product polynomial at
+ * Compute the grad of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th tensor
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Returns the number of tensor product polynomials. For <i>n</i> 1d
+ * Return the number of tensor product polynomials. For <i>n</i> 1d
* polynomials this is <i>n<sup>dim</sup></i>.
*/
unsigned int n () const;
AnisotropicPolynomials (const std::vector<std::vector<Polynomials::Polynomial<double> > > &pols);
/**
- * Computes the value and the first and second derivatives of each tensor
+ * Compute the value and the first and second derivatives of each tensor
* product polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal <tt>0</tt> or equal
std::vector<Tensor<4,dim> > &fourth_derivatives) const;
/**
- * Computes the value of the <tt>i</tt>th tensor product polynomial at
+ * Compute the value of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
+ * Compute the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Computes the grad of the <tt>i</tt>th tensor product polynomial at
+ * Compute the grad of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th tensor
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Returns the number of tensor product polynomials. It is the product of
+ * Return the number of tensor product polynomials. It is the product of
* the number of polynomials in each coordinate direction.
*/
unsigned int n () const;
TensorProductPolynomialsBubbles (const std::vector<Pol> &pols);
/**
- * Computes the value and the first and second derivatives of each tensor
+ * Compute the value and the first and second derivatives of each tensor
* product polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal 0 or equal n(). In the first
std::vector<Tensor<4,dim> > &fourth_derivatives) const;
/**
- * Computes the value of the <tt>i</tt>th tensor product polynomial at
+ * Compute the value of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the order @p order derivative of the <tt>i</tt>th tensor product
+ * Compute the order @p order derivative of the <tt>i</tt>th tensor product
* polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor
* product numbering.
*
const Point<dim> &p) const;
/**
- * Computes the grad of the <tt>i</tt>th tensor product polynomial at
+ * Compute the grad of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th tensor
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Returns the number of tensor product polynomials plus the bubble
+ * Return the number of tensor product polynomials plus the bubble
* enrichments. For <i>n</i> 1d polynomials this is <i>n<sup>dim</sup>+1</i>
* if the maximum degree of the polynomials is one and
* <i>n<sup>dim</sup>+dim</i> otherwise.
TensorProductPolynomialsConst (const std::vector<Pol> &pols);
/**
- * Computes the value and the first and second derivatives of each tensor
+ * Compute the value and the first and second derivatives of each tensor
* product polynomial at <tt>unit_point</tt>.
*
* The size of the vectors must either be equal 0 or equal n(). In the first
std::vector<Tensor<4,dim> > &fourth_derivatives) const;
/**
- * Computes the value of the <tt>i</tt>th tensor product polynomial at
+ * Compute the value of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
+ * Compute the <tt>order</tt>th derivative of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Computes the grad of the <tt>i</tt>th tensor product polynomial at
+ * Compute the grad of the <tt>i</tt>th tensor product polynomial at
* <tt>unit_point</tt>. Here <tt>i</tt> is given in tensor product
* numbering.
*
const Point<dim> &p) const;
/**
- * Computes the second derivative (grad_grad) of the <tt>i</tt>th tensor
+ * Compute the second derivative (grad_grad) of the <tt>i</tt>th tensor
* product polynomial at <tt>unit_point</tt>. Here <tt>i</tt> is given in
* tensor product numbering.
*
const Point<dim> &p) const;
/**
- * Returns the number of tensor product polynomials plus the constant
+ * Return the number of tensor product polynomials plus the constant
* function. For <i>n</i> 1d polynomials this is <i>n<sup>dim</sup>+1</i>.
*/
unsigned int n () const;
void clear ();
/**
- * Returns a reference to the internal Threading Building Blocks
+ * Return a reference to the internal Threading Building Blocks
* implementation. This function is really only useful if deal.II has been
* configured with multithreading and has no useful purpose otherwise.
*/
const bool sync_wall_time = false);
/**
- * Returns a reference to the data structure with global timing information.
+ * Return a reference to the data structure with global timing information.
* Filled after calling stop().
*/
const Utilities::MPI::MinMaxAvg &get_data() const;
void start ();
/**
- * Sets the current time as next starting time and return the elapsed time
+ * Set the current time as next starting time and return the elapsed time
* in seconds.
*/
double stop ();
double wall_time () const;
/**
- * Returns the last lap time; the time taken between the last start()/stop()
+ * Return the last lap time; the time taken between the last start()/stop()
* call.
*/
double get_lap_time () const;
namespace Trilinos
{
/**
- * Returns a Trilinos Epetra_Comm object needed for creation of
+ * Return a Trilinos Epetra_Comm object needed for creation of
* Epetra_Maps.
*
* If deal.II has been configured to use a compiler that does not support
const Epetra_Comm &comm_world();
/**
- * Returns a Trilinos Epetra_Comm object needed for creation of
+ * Return a Trilinos Epetra_Comm object needed for creation of
* Epetra_Maps.
*
* If deal.II has been configured to use a compiler that does not support
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by the amount of bytes
* in the vectorized array, as opposed to casting a double address to
* VectorizedArray<double>*.
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* the amount of bytes in the vectorized array, as opposed to casting a
* double address to VectorizedArray<double>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 64 bytes, as opposed
* to casting a double address to VectorizedArray<double>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 64 bytes, as opposed to casting a double address to
* VectorizedArray<double>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 64 bytes, as opposed
* to casting a float address to VectorizedArray<float>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 64 bytes, as opposed to casting a float address to
* VectorizedArray<float>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 32 bytes, as opposed
* to casting a double address to VectorizedArray<double>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 32 bytes, as opposed to casting a double address to
* VectorizedArray<double>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 32 bytes, as opposed
* to casting a float address to VectorizedArray<float>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 32 bytes, as opposed to casting a float address to
* VectorizedArray<float>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 16 bytes, as opposed
* to casting a double address to VectorizedArray<double>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 16 bytes, as opposed to casting a double address to
* VectorizedArray<double>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
}
/**
- * Loads @p n_array_elements from memory into the calling class, starting at
+ * Load @p n_array_elements from memory into the calling class, starting at
* the given address. The memory need not be aligned by 16 bytes, as opposed
* to casting a float address to VectorizedArray<float>*.
*/
}
/**
- * Writes the content of the calling class into memory in form of @p
+ * Write the content of the calling class into memory in form of @p
* n_array_elements to the given address. The memory need not be aligned by
* 16 bytes, as opposed to casting a float address to
* VectorizedArray<float>*.
private:
/**
- * Returns the square root of this field. Not for use in user code. Use
+ * Return the square root of this field. Not for use in user code. Use
* sqrt(x) instead.
*/
VectorizedArray
}
/**
- * Returns the absolute value of this field. Not for use in user code. Use
+ * Return the absolute value of this field. Not for use in user code. Use
* abs(x) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise maximum of this field and another one. Not for
+ * Return the component-wise maximum of this field and another one. Not for
* use in user code. Use max(x,y) instead.
*/
VectorizedArray
}
/**
- * Returns the component-wise minimum of this field and another one. Not for
+ * Return the component-wise minimum of this field and another one. Not for
* use in user code. Use min(x,y) instead.
*/
VectorizedArray
namespace std
{
/**
- * Computes the sine of a vectorized data field. The result is returned as
+ * Compute the sine of a vectorized data field. The result is returned as
* vectorized array in the form <tt>{sin(x[0]), sin(x[1]), ...,
* sin(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the cosine of a vectorized data field. The result is returned as
+ * Compute the cosine of a vectorized data field. The result is returned as
* vectorized array in the form <tt>{cos(x[0]), cos(x[1]), ...,
* cos(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the tangent of a vectorized data field. The result is returned
+ * Compute the tangent of a vectorized data field. The result is returned
* as vectorized array in the form <tt>{tan(x[0]), tan(x[1]), ...,
* tan(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the exponential of a vectorized data field. The result is
+ * Compute the exponential of a vectorized data field. The result is
* returned as vectorized array in the form <tt>{exp(x[0]), exp(x[1]), ...,
* exp(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the natural logarithm of a vectorized data field. The result is
+ * Compute the natural logarithm of a vectorized data field. The result is
* returned as vectorized array in the form <tt>{log(x[0]), log(x[1]), ...,
* log(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the square root of a vectorized data field. The result is
+ * Compute the square root of a vectorized data field. The result is
* returned as vectorized array in the form <tt>{sqrt(x[0]), sqrt(x[1]),
* ..., sqrt(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the absolute value (modulus) of a vectorized data field. The
+ * Compute the absolute value (modulus) of a vectorized data field. The
* result is returned as vectorized array in the form <tt>{abs(x[0]),
* abs(x[1]), ..., abs(x[n_array_elements-1])}</tt>.
*
/**
- * Computes the componentwise maximum of two vectorized data fields. The
+ * Compute the componentwise maximum of two vectorized data fields. The
* result is returned as vectorized array in the form <tt>{max(x[0],y[0]),
* max(x[1],y[1]), ...}</tt>.
*
/**
- * Computes the componentwise minimum of two vectorized data fields. The
+ * Compute the componentwise minimum of two vectorized data fields. The
* result is returned as vectorized array in the form <tt>{min(x[0],y[0]),
* min(x[1],y[1]), ...}</tt>.
*
/**
- * Returns whether q1 and q2 are equal
+ * Return whether q1 and q2 are equal
*/
template <int dim>
bool
/**
- * Returns true if the triangulation has hanging nodes.
+ * Return true if the triangulation has hanging nodes.
*
* In the context of parallel distributed triangulations, every
* processor stores only that part of the triangulation it locally owns.
virtual ~Triangulation ();
/**
- * Returns a permutation vector for the order the coarse cells are
+ * Return a permutation vector for the order the coarse cells are
* handed of to p4est. For example the first element i in this vector
* denotes that the first cell in hierarchical ordering is the ith deal
* cell starting from begin(0).
/**
- * Returns the global maximum level. This may be bigger than the number
+ * Return the global maximum level. This may be bigger than the number
* dealii::Triangulation::n_levels() (a function in this class's base
* class) returns if the current processor only stores cells in parts of
* the domain that are not very refined, but if other processors store
types::subdomain_id locally_owned_subdomain () const;
/**
- * Returns a set of MPI ranks of the processors that have at least one
+ * Return a set of MPI ranks of the processors that have at least one
* ghost cell adjacent to the cells of the local processor. In other
* words, this is the set of subdomain_id() for all ghost cells.
*
const std::set<unsigned int> &ghost_owners () const;
/**
- * Returns a set of MPI ranks of the processors that have at least one
+ * Return a set of MPI ranks of the processors that have at least one
* level ghost cell adjacent to our cells used in geometric multigrid. In
* other words, this is the set of level_subdomain_id() for all level
* ghost cells.
const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
/**
- * Sets the level DoF indices that are returned by get_mg_dof_indices.
+ * Set the level DoF indices that are returned by get_mg_dof_indices.
*/
void set_mg_dof_indices (const int level,
const std::vector<types::global_dof_index> &dof_indices,
const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
/**
- * Returns the global DoF index of the <code>i</code>th degree of freedom
+ * Return the global DoF index of the <code>i</code>th degree of freedom
* associated with the <code>vertex</code>th vertex on level @p level. Also
* see vertex_dof_index().
*/
const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
/**
- * Returns the dof_index on the given level. Also see dof_index.
+ * Return the dof_index on the given level. Also see dof_index.
*/
types::global_dof_index mg_dof_index (const int level, const unsigned int i) const;
get_fe () const;
/**
- * Returns the index inside the hp::FECollection of the FiniteElement used
+ * Return the index inside the hp::FECollection of the FiniteElement used
* for this cell. This function is only useful if the DoF handler object
* associated with the current cell is an hp::DoFHandler.
*
unsigned int active_fe_index () const;
/**
- * Sets the index of the FiniteElement used for this cell. This determines
+ * Set the index of the FiniteElement used for this cell. This determines
* which element in an hp::FECollection to use. This function is only useful
* if the DoF handler object associated with the current cell is an
* hp::DoFHandler.
const IndexSet &locally_owned_dofs() const;
/**
- * Returns an IndexSet describing the set of locally owned DoFs used for the
+ * Return an IndexSet describing the set of locally owned DoFs used for the
* given multigrid level as a subset of 0..n_dofs(level).
*/
const IndexSet &locally_owned_mg_dofs(const unsigned int level) const;
/**
- * Returns a vector that stores the locally owned DoFs of each processor. If
+ * Return a vector that stores the locally owned DoFs of each processor. If
* you are only interested in the number of elements each processor owns
* then n_locally_owned_dofs_per_processor() is a better choice.
*
const bool use_constraints = false);
/**
- * Computes the renumbering vector needed by the Cuthill_McKee() function.
+ * Compute the renumbering vector needed by the Cuthill_McKee() function.
* Does not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
= std::vector<types::global_dof_index>());
/**
- * Computes the renumbering vector needed by the Cuthill_McKee() function.
+ * Compute the renumbering vector needed by the Cuthill_McKee() function.
* Does not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
= std::vector<unsigned int>());
/**
- * Computes the renumbering vector needed by the component_wise() functions.
+ * Compute the renumbering vector needed by the component_wise() functions.
* Does not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
block_wise (hp::DoFHandler<dim,spacedim> &dof_handler);
/**
- * Computes the renumbering vector needed by the block_wise() functions.
+ * Compute the renumbering vector needed by the block_wise() functions.
* Does not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
const bool dof_wise_renumbering = false);
/**
- * Computes the renumbering vector needed by the downstream() function. Does
+ * Compute the renumbering vector needed by the downstream() function. Does
* not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
const bool dof_wise_renumbering);
/**
- * Computes the renumbering vector needed by the downstream() function. Does
+ * Compute the renumbering vector needed by the downstream() function. Does
* not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
const bool counter = false);
/**
- * Computes the renumbering vector needed by the clockwise_dg() functions.
+ * Compute the renumbering vector needed by the clockwise_dg() functions.
* Does not perform the renumbering on the DoFHandler dofs but returns the
* renumbering vector.
*/
const unsigned int level);
/**
- * Computes the renumbering vector needed by the sort_selected_dofs_back()
+ * Compute the renumbering vector needed by the sort_selected_dofs_back()
* function. Does not perform the renumbering on the DoFHandler dofs but
* returns the renumbering vector.
*
random (DoFHandlerType &dof_handler);
/**
- * Computes the renumbering vector needed by the random() function. See
+ * Compute the renumbering vector needed by the random() function. See
* there for more information on the computed random renumbering.
*
* This function does not perform the renumbering on the DoFHandler dofs but
subdomain_wise (DoFHandlerType &dof_handler);
/**
- * Computes the renumbering vector needed by the subdomain_wise() function.
+ * Compute the renumbering vector needed by the subdomain_wise() function.
* Does not perform the renumbering on the @p DoFHandler dofs but returns
* the renumbering vector.
*/
block_mask (const ComponentMask &component_mask) const;
/**
- * Returns a list of constant modes of the element. The number of rows in
+ * Return a list of constant modes of the element. The number of rows in
* the resulting table depends on the elements in use. For standard
* elements, the table has as many rows as there are components in the
* element and dofs_per_cell columns. To each component of the finite
get_generalized_support_points () const;
/**
- * Returns <tt>true</tt> if the class provides nonempty vectors either from
+ * Return <tt>true</tt> if the class provides nonempty vectors either from
* get_unit_support_points() or get_generalized_support_points().
*
* See the
};
/**
- * Returns a list of constant modes of the element. For this element, the
+ * Return a list of constant modes of the element. For this element, the
* first entry is true, all other are false.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
const unsigned int face_index) const;
/**
- * Returns a list of constant modes of the element. For this element, it
+ * Return a list of constant modes of the element. For this element, it
* simply returns one row with all entries set to true.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
compare_for_face_domination (const FiniteElement<dim,spacedim> &fe_other) const;
/**
- * Returns a list of constant modes of the element. For this element, it
+ * Return a list of constant modes of the element. For this element, it
* simply returns one row with all entries set to true.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
compare_for_face_domination (const FiniteElement<1,spacedim> &fe_other) const;
/**
- * Returns a list of constant modes of the element. For this element, it
+ * Return a list of constant modes of the element. For this element, it
* simply returns one row with all entries set to true.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
compare_for_face_domination (const FiniteElement<dim,spacedim> &fe_other) const;
/**
- * Returns a list of constant modes of the element. For this element, the
+ * Return a list of constant modes of the element. For this element, the
* first entry on each face is true, all other are false (as the constant
* function is represented by the first base function of Legendre
* polynomials).
FE_FaceP (const unsigned int p);
/**
- * Returns the name of the element
+ * Return the name of the element
*/
std::string get_name() const;
};
const;
/**
- * Returns a list of constant modes of the element.
+ * Return a list of constant modes of the element.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
get_constant_modes () const;
FE_Q (const Quadrature<1> &points);
/**
- * Constructs a FE_Q_isoQ1 element. That element shares large parts of code
+ * Construct a FE_Q_isoQ1 element. That element shares large parts of code
* with FE_Q so most of the construction work is done in this routine,
* whereas the public constructor is in the class FE_Q_isoQ1.
*/
const bool face_rotation = false) const;
/**
- * Returns a list of constant modes of the element. For this element, the
+ * Return a list of constant modes of the element. For this element, the
* list consists of true arguments for all components.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
private:
/**
- * Returns the restriction_is_additive flags. Only the last components for
+ * Return the restriction_is_additive flags. Only the last components for
* the bubble enrichments are true.
*/
static std::vector<bool> get_riaf_vector(const unsigned int degree);
const unsigned int face_index) const;
/**
- * Returns a list of constant modes of the element. For this element, there
+ * Return a list of constant modes of the element. For this element, there
* are two constant modes despite the element is scalar: The first constant
* mode is all ones for the usual FE_Q basis and the second one only using
* the discontinuous part.
private:
/**
- * Returns the restriction_is_additive flags. Only the last component is
+ * Return the restriction_is_additive flags. Only the last component is
* true.
*/
static std::vector<bool> get_riaf_vector(const unsigned int degree);
std::vector<unsigned int> get_embedding_dofs (const unsigned int sub_degree) const;
/**
- * Returns a list of constant modes of the element. For this element, the
+ * Return a list of constant modes of the element. For this element, the
* list consists of true arguments for the first vertex shape functions and
* false for the remaining ones.
*/
{
public:
/**
- * Constructs a FE_Q_iso_Q1 element with a given number of subdivisions. The
+ * Construct a FE_Q_iso_Q1 element with a given number of subdivisions. The
* number of subdivision is similar to the degree in FE_Q in the sense that
* both elements produce the same number of degrees of freedom.
*/
const VectorSlice<const std::vector<std::vector<double> > > &values) const;
/**
- * Returns a list of constant modes of the element. This method is currently
+ * Return a list of constant modes of the element. This method is currently
* not correctly implemented because it returns ones for all components.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
unit_face_support_point (const unsigned int index) const;
/**
- * Returns a list of constant modes of the element. The returns table has as
+ * Return a list of constant modes of the element. The returns table has as
* many rows as there are components in the element and dofs_per_cell
* columns. To each component of the finite element, the row in the returned
* table contains a basis representation of the constant function 1 on the
FullMatrix<double> &I_q);
/**
- * Computes the projection of tensorial (first-order tensor) data stored at
+ * Compute the projection of tensorial (first-order tensor) data stored at
* the quadrature points @p vector_of_tensors_at_qp to data @p
* vector_of_tensors_at_nodes at the support points of the cell. The data
* in @p vector_of_tensors_at_qp is ordered sequentially following the
const unsigned int face_index) const;
/**
- * Returns a list of constant modes of the element. For this element, it
+ * Return a list of constant modes of the element. For this element, it
* simply returns one row with all entries set to true.
*/
virtual std::pair<Table<2,bool>, std::vector<unsigned int> >
FE_TraceQ (const unsigned int p);
/**
- * Returns the name of the element
+ * Return the name of the element
*/
std::string get_name() const;
};
//@{
/**
- * Returns the values of a finite element function restricted to the current
+ * Return the values of a finite element function restricted to the current
* cell, face or subface selected the last time the <tt>reinit</tt> function
* of the derived class was called, at the quadrature points.
*
get_vertices (const typename Triangulation<dim,spacedim>::cell_iterator &cell) const;
/**
- * Returns whether the mapping preserves vertex locations. In other words,
+ * Return whether the mapping preserves vertex locations. In other words,
* this function returns whether the mapped location of the reference cell
* vertices (given by GeometryInfo::unit_cell_vertex()) equals the result of
* <code>cell-@>vertex()</code> (i.e., information stored by the
void read_tecplot (std::istream &in);
/**
- * Returns the standard suffix for a file in this format.
+ * Return the standard suffix for a file in this format.
*/
static std::string default_suffix (const Format format);
const unsigned int localsidenum);
/**
- * Returns true if all sides of the quad quadnum are oriented.
+ * Return true if all sides of the quad quadnum are oriented.
*/
bool is_fully_oriented_quad (const unsigned int quadnum) const;
/**
- * Returns true if the side lsn of the quad quadnum is oriented.
+ * Return true if the side lsn of the quad quadnum is oriented.
*/
bool is_oriented_side (const unsigned int quadnum,
const unsigned int lsn) const;
/**
- * Returns true is the side is oriented in the "default" direction
+ * Return true is the side is oriented in the "default" direction
*/
bool is_side_default_oriented (const unsigned int qnum,
const unsigned int lsn) const;
std::vector<Cell> cell_list;
/**
- * Checks whether every cell in the mesh is sensible.
+ * Check whether every cell in the mesh is sensible.
*/
void sanity_check() const;
* This function is the single entry point to the functionality of this
* class.
*
- * Returns, whether a consistent orientation of lines was possible for
+ * Return, whether a consistent orientation of lines was possible for
* the given mesh.
*/
static
/**
* Orient all the edges of a mesh.
*
- * Returns, whether this action was carried out successfully.
+ * Return, whether this action was carried out successfully.
*/
bool orient_edges ();
const Function<dim,double> *coefficient = 0);
/**
- * Returns a std::map with all vertices of faces located in the boundary
+ * Return a std::map with all vertices of faces located in the boundary
*
* @param[in] tria The Triangulation object.
*/
void restore (const unsigned int step_no);
/**
- * Returns the number of refinement and coarsening steps. This is given by
+ * Return the number of refinement and coarsening steps. This is given by
* the size of the @p refine_flags vector.
*/
unsigned int n_refinement_steps () const;
const SubCellData &subcelldata);
/**
- * Writes all refine and coarsen flags to the ostream @p out.
+ * Write all refine and coarsen flags to the ostream @p out.
*/
virtual void write_flags(std::ostream &out) const;
virtual void read_flags(std::istream &in);
/**
- * Clears all flags. Retains the same coarse grid.
+ * Clear all flags. Retains the same coarse grid.
*/
virtual void clear_flags();
virtual void clear ();
/**
- * Sets the mesh smoothing to @p mesh_smoothing. This overrides the
+ * Set the mesh smoothing to @p mesh_smoothing. This overrides the
* MeshSmoothing given to the constructor. It is allowed to call this
* function only if the triangulation is empty.
*/
const Manifold<dim,spacedim> &get_manifold (const types::manifold_id number) const;
/**
- * Returns a vector containing all boundary indicators assigned to boundary
+ * Return a vector containing all boundary indicators assigned to boundary
* faces of this Triangulation object. Note, that each boundary indicator is
* reported only once. The size of the return vector will represent the
* number of different indicators (which is greater or equal one).
std::vector<types::boundary_id> get_boundary_ids() const;
/**
- * Returns a vector containing all manifold indicators assigned to the
+ * Return a vector containing all manifold indicators assigned to the
* objects of this Triangulation. Note, that each manifold indicator is
* reported only once. The size of the return vector will represent the
* number of different indicators (which is greater or equal one).
double extent_in_direction (const unsigned int axis) const;
/**
- * Returns the minimal distance between any two vertices.
+ * Return the minimal distance between any two vertices.
*/
double minimum_vertex_distance () const;
/**
- * Returns a point belonging to the Manifold<dim,spacedim> where this object
+ * Return a point belonging to the Manifold<dim,spacedim> where this object
* lives, given its parametric coordinates on the reference @p structdim
* cell. This function queries the underlying manifold object, and can be
* used to obtain the exact geometrical location of arbitrary points on this
neighbor_or_periodic_neighbor (const unsigned int i) const;
/**
- * Returns an iterator to the periodic neighbor of the cell at a given
+ * Return an iterator to the periodic neighbor of the cell at a given
* face and subface number. The general guidelines for using this function
* is similar to the function neighbor_child_on_subface(). The
* implementation of this function is consistent with
protected:
/**
- * Returns the support points of the Gauss-Lobatto quadrature formula used
+ * Return the support points of the Gauss-Lobatto quadrature formula used
* for intermediate points.
*
* @note Since the boundary description is closely tied to the unit cell
/**
* Constructor. The center of the spheres defaults to the origin.
*
- * Calls the constructor of its base @p HyperBallBoundary class with a dummy
+ * Call the constructor of its base @p HyperBallBoundary class with a dummy
* radius as argument. This radius will be ignored
*/
HyperShellBoundary (const Point<dim> ¢er = Point<dim>());
/**
- * Returns a vector that stores the locally owned DoFs of each processor.
+ * Return a vector that stores the locally owned DoFs of each processor.
* If you are only interested in the number of elements each processor
* owns then n_dofs_per_processor() is a better choice.
*
void push_back (const Mapping<dim,spacedim> &new_mapping);
/**
- * Returns the mapping object which was specified by the user for the
+ * Return the mapping object which was specified by the user for the
* active_fe_index which is provided as a parameter to this method.
*
* @pre @p index must be between zero and the number of elements of the
operator[] (const unsigned int index) const;
/**
- * Returns the number of mapping objects stored in this container.
+ * Return the number of mapping objects stored in this container.
*/
unsigned int size () const;
void push_back (const Quadrature<dim> &new_quadrature);
/**
- * Returns a reference to the quadrature rule specified by the argument.
+ * Return a reference to the quadrature rule specified by the argument.
*
* @pre @p index must be between zero and the number of elements of the
* collection.
operator[] (const unsigned int index) const;
/**
- * Returns the number of quadrature pointers stored in this object.
+ * Return the number of quadrature pointers stored in this object.
*/
unsigned int size () const;
iparam[2] = control().max_steps();
/**
- * Sets the mode of dsaupd. 1 is exact shifting, 2 is user-supplied shifts,
+ * Set the mode of dsaupd. 1 is exact shifting, 2 is user-supplied shifts,
* 3 is shift-invert mode, 4 is buckling mode, 5 is Cayley mode.
*/
const BlockVectorBase &W);
/**
- * Returns true if the given global index is in the local range of this
+ * Return true if the given global index is in the local range of this
* processor. Asks the corresponding block.
*/
bool in_local_range (const size_type global_index) const;
unsigned int row () const;
/**
- * Returns the global index from the reduced sparsity pattern.
+ * Return the global index from the reduced sparsity pattern.
*/
std::size_t reduced_index() const;
bool can_store_line (const size_type line_index) const;
/**
- * Returns the index set describing locally relevant lines if any are
+ * Return the index set describing locally relevant lines if any are
* present. Note that if no local lines were given, this represents an empty
* IndexSet, whereas otherwise it contains the global problem size and the
* local range.
size_type max_constraint_indirections () const;
/**
- * Returns <tt>true</tt> in case the dof is constrained and there is a non-
+ * Return <tt>true</tt> in case the dof is constrained and there is a non-
* trivial inhomogeneous values set to the dof.
*/
bool is_inhomogeneously_constrained (const size_type index) const;
/**
- * Returns <tt>false</tt> if all constraints in the ConstraintMatrix are
+ * Return <tt>false</tt> if all constraints in the ConstraintMatrix are
* homogeneous ones, and <tt>true</tt> if there is at least one
* inhomogeneity.
*/
bool has_inhomogeneities () const;
/**
- * Returns a pointer to the the vector of entries if a line is constrained,
+ * Return a pointer to the the vector of entries if a line is constrained,
* and a zero pointer in case the dof is not constrained.
*/
const std::vector<std::pair<size_type,double> > *
get_constraint_entries (const size_type line) const;
/**
- * Returns the value of the inhomogeneity stored in the constrained dof @p
+ * Return the value of the inhomogeneity stored in the constrained dof @p
* line. Unconstrained dofs also return a zero value.
*/
double get_inhomogeneity (const size_type line) const;
BlockVectorType &vector) const;
/**
- * Sets the values of all constrained DoFs in a vector to zero. The @p
+ * Set the values of all constrained DoFs in a vector to zero. The @p
* VectorType may be a Vector<float>, Vector<double>,
* BlockVector<tt><...></tt>, a PETSc or Trilinos vector wrapper class, or
* any other type having the same interface.
real_type relative_symmetry_norm2 () const;
/**
- * Computes the determinant of a matrix. This is only implemented for one,
+ * Compute the determinant of a matrix. This is only implemented for one,
* two, and three dimensions, since for higher dimensions the numerical work
* explodes. Obviously, the matrix needs to be quadratic for this function.
*/
void zero_out_ghosts ();
/**
- * Returns if this Vector contains ghost elements.
+ * Return if this Vector contains ghost elements.
*/
bool has_ghost_elements() const;
bool all_zero () const;
/**
- * Computes the mean value of all the entries in the vector.
+ * Compute the mean value of all the entries in the vector.
*/
Number mean_value () const;
Vector (const Vector<Number> &in_vector);
/**
- * Constructs a parallel vector of the given global size without any
+ * Construct a parallel vector of the given global size without any
* actual parallel distribution.
*/
Vector (const size_type size);
/**
- * Constructs a parallel vector. The local range is specified by @p
+ * Construct a parallel vector. The local range is specified by @p
* locally_owned_set (note that this must be a contiguous interval,
* multiple intervals are not possible). The IndexSet @p ghost_indices
* specifies ghost indices, i.e., indices which one might need to read
virtual ~Vector ();
/**
- * Sets the global size of the vector to @p size without any actual
+ * Set the global size of the vector to @p size without any actual
* parallel distribution.
*/
void reinit (const size_type size,
void zero_out_ghosts ();
/**
- * Returns whether the vector currently is in a state where ghost values
+ * Return whether the vector currently is in a state where ghost values
* can be read or not. This is the same functionality as other parallel
* vectors have. If this method returns false, this only means that
* read-access to ghost elements is prohibited whereas write access is
//@{
/**
- * Returns the local size of the vector, i.e., the number of indices
+ * Return the local size of the vector, i.e., the number of indices
* owned locally.
*/
size_type local_size() const;
/**
- * Returns the half-open interval that specifies the locally owned range
+ * Return the half-open interval that specifies the locally owned range
* of the vector. Note that <code>local_size() == local_range().second -
* local_range().first</code>.
*
std::pair<size_type, size_type> local_range () const DEAL_II_DEPRECATED;
/**
- * Returns true if the given global index is in the local range of this
+ * Return true if the given global index is in the local range of this
* processor.
*
* This function is deprecated.
bool in_local_range (const size_type global_index) const DEAL_II_DEPRECATED;
/**
- * Returns the number of ghost elements present on the vector.
+ * Return the number of ghost elements present on the vector.
*
* This function is deprecated.
*/
const IndexSet &ghost_elements() const DEAL_II_DEPRECATED;
/**
- * Returns whether the given global index is a ghost index on the
+ * Return whether the given global index is a ghost index on the
* present processor. Returns false for indices that are owned locally
* and for indices not present at all.
*
bool all_zero () const;
/**
- * Computes the mean value of all the entries in the vector.
+ * Compute the mean value of all the entries in the vector.
*/
Number mean_value () const;
get_partitioner () const;
/**
- * Checks whether the given partitioner is compatible with the
+ * Check whether the given partitioner is compatible with the
* partitioner used for this vector. Two partitioners are compatible if
* they have the same local size and the same ghost indices. They do not
* necessarily need to be the same data field of the shared pointer.
partitioners_are_compatible (const Utilities::MPI::Partitioner &part) const;
/**
- * Checks whether the given partitioner is compatible with the
+ * Check whether the given partitioner is compatible with the
* partitioner used for this vector. Two partitioners are compatible if
* they have the same local size and the same ghost indices. They do not
* necessarily need to be the same data field. As opposed to
void block_read (std::istream &in);
/**
- * Returns the memory consumption of this class in bytes.
+ * Return the memory consumption of this class in bytes.
*/
virtual std::size_t memory_consumption() const;
/**
* @relates LinearOperator
*
- * Returns the transpose linear operations of @p op.
+ * Return the transpose linear operations of @p op.
*
* @ingroup LAOperators
*/
/**
* @relates LinearOperator
*
- * Returns an object representing the inverse of the LinearOperator @p op.
+ * Return an object representing the inverse of the LinearOperator @p op.
*
* The function takes references @p solver and @p preconditioner to an
* iterative solver and a preconditioner that are used in the
/**
* @relates LinearOperator
*
- * Returns a LinearOperator that is the identity of the vector space @p Range.
+ * Return a LinearOperator that is the identity of the vector space @p Range.
*
* The function takes an <code>std::function</code> object @p reinit_vector as
* an argument to initialize the <code>reinit_range_vector</code> and
/**
* @relates LinearOperator
*
- * Returns a nulled variant of the LinearOperator @p op, i.e. with optimized
+ * Return a nulled variant of the LinearOperator @p op, i.e. with optimized
* LinearOperator::vmult, LinearOperator::vmult_add, etc. functions and with
* LinearOperator::is_null_operator set to true.
*
void reinit(const BlockSparsityPattern &sparsity);
/**
- * Clears the object.
+ * Clear the object.
*
* Since often only clearing of the individual matrices is desired, but not
* removing the blocks themselves, there is an optional argument. If the
void reinit_edge_flux(const MGLevelObject<BlockSparsityPattern> &sparsity);
/**
- * Clears the object.
+ * Clear the object.
*
* Since often only clearing of the individual matrices is desired, but not
* removing the blocks themselves, there is an optional argument. If the
const bool alternative_output = false) const;
/**
- * Returns the number bytes consumed by this matrix on this CPU.
+ * Return the number bytes consumed by this matrix on this CPU.
*/
std::size_t memory_consumption() const;
const unsigned int this_process);
/**
- * Calls the @p reinit() function above with <tt>communicator =
+ * Call the @p reinit() function above with <tt>communicator =
* MPI_COMM_WORLD</tt>.
*/
void reinit (const unsigned int m,
const unsigned int local_columns);
/**
- * Calls the @p reinit() function above with <tt>communicator =
+ * Call the @p reinit() function above with <tt>communicator =
* MPI_COMM_WORLD</tt>.
*/
void reinit (const unsigned int m,
void reinit (const unsigned int num_blocks);
/**
- * Returns if this vector is a ghosted vector (and thus read-only).
+ * Return if this vector is a ghosted vector (and thus read-only).
*/
bool has_ghost_elements() const;
const size_type local_size);
/**
- * Constructs a new parallel ghosted PETSc vector from an IndexSet. Note
+ * Construct a new parallel ghosted PETSc vector from an IndexSet. Note
* that @p local must be contiguous and the global size of the vector is
* determined by local.size(). The global indices in @p ghost are
* supplied as ghost indices that can also be read locally.
const MPI_Comm &communicator);
/**
- * Constructs a new parallel PETSc vector from an IndexSet. This creates
+ * Construct a new parallel PETSc vector from an IndexSet. This creates
* a non ghosted vector.
*/
explicit Vector (const IndexSet &local,
const AdditionalData &additional_data = AdditionalData());
/**
- * Computes the action of the preconditioner on <tt>src</tt>, storing the
+ * Compute the action of the preconditioner on <tt>src</tt>, storing the
* result in <tt>dst</tt>.
*/
void vmult (VectorType &dst,
const VectorType &src) const;
/**
- * Computes the action of the transposed preconditioner on <tt>src</tt>,
+ * Compute the action of the transposed preconditioner on <tt>src</tt>,
* storing the result in <tt>dst</tt>.
*/
void Tvmult (VectorType &dst,
void clear();
/**
- * Checks whether the object is empty.
+ * Check whether the object is empty.
*/
bool empty () const;
bool inverses_ready () const;
/**
- * Checks whether the object is empty.
+ * Check whether the object is empty.
*/
bool empty () const;
ReadWriteVector (const ReadWriteVector<Number> &in_vector);
/**
- * Constructs a vector given the size, the stored elements have their
+ * Construct a vector given the size, the stored elements have their
* index in [0,size).
*/
explicit ReadWriteVector (const size_type size);
/**
- * Constructs a vector whose stored elements indices are given by the
+ * Construct a vector whose stored elements indices are given by the
* IndexSet @p locally_stored_indices.
*/
explicit ReadWriteVector (const IndexSet &locally_stored_indices);
~ReadWriteVector ();
/**
- * Sets the global size of the vector to @p size. The stored elements have
+ * Set the global size of the vector to @p size. The stored elements have
* their index in [0,size).
*
* If the flag @p omit_zeroing_entries is set to false, the memory will be
iterator begin ();
/**
- * Returns constant iterator to the start of the locally stored elements
+ * Return constant iterator to the start of the locally stored elements
* of the vector.
*/
const_iterator begin () const;
/**
- * Returns an iterator pointing to the element past the end of the array
+ * Return an iterator pointing to the element past the end of the array
* of locally stored entries.
*/
iterator end ();
/**
- * Returns a constant iterator pointing to the element past the end of the
+ * Return a constant iterator pointing to the element past the end of the
* array of the locally stored entries.
*/
const_iterator end () const;
const bool scientific = true) const;
/**
- * Returns the memory consumption of this class in bytes.
+ * Return the memory consumption of this class in bytes.
*/
std::size_t memory_consumption () const;
//@}
void clear();
/**
- * Checks whether the object is empty.
+ * Check whether the object is empty.
*/
bool empty () const;
/**
* @relates LinearOperator
*
- * Returns a LinearOperator that performs the operations associated with the
+ * Return a LinearOperator that performs the operations associated with the
* Schur complement. There are two additional helper functions,
* condense_schur_rhs() and postprocess_schur_solution(), that are likely
* necessary to be used in order to perform any useful tasks in linear algebra
void log_history (const bool);
/**
- * Returns the @p log_history flag.
+ * Return the @p log_history flag.
*/
bool log_history () const;
void log_result (const bool);
/**
- * Returns the @p log_result flag.
+ * Return the @p log_result flag.
*/
bool log_result () const;
const VectorType &temp);
/**
- * Returns size of data vector. It is used in the solver to store
+ * Return size of data vector. It is used in the solver to store
* the Arnoldi vectors.
*/
unsigned int size() const;
const double drop_tolerance=1e-13);
/**
- * Returns the state of the matrix, i.e., whether compress() needs to be
+ * Return the state of the matrix, i.e., whether compress() needs to be
* called after an operation requiring data exchange. Does only return
* non-true values when used in <tt>debug</tt> mode, since it is quite
* expensive to keep track of all operations that lead to the need for
/**
- * Returns the l<sub>1</sub> norm of the vector (i.e., the sum of the
+ * Return the l<sub>1</sub> norm of the vector (i.e., the sum of the
* absolute values of all entries among all processors).
*/
virtual double l1_norm() const;
/**
- * Returns the l<sub>2</sub> norm of the vector (i.e., the square root of
+ * Return the l<sub>2</sub> norm of the vector (i.e., the square root of
* the sum of the square of all entries among all processors).
*/
virtual double l2_norm() const;
/**
- * Returns the maximum norm of the vector (i.e., the maximum absolute value
+ * Return the maximum norm of the vector (i.e., the maximum absolute value
* among all entries and among all processors).
*/
virtual double linfty_norm() const;
const VectorSpaceVector<double> &W);
/**
- * Returns the global size of the vector, equal to the sum of the number of
+ * Return the global size of the vector, equal to the sum of the number of
* locally owned indices among all processors.
*/
virtual size_type size() const;
const bool across=true) const;
/**
- * Returns the memory consumption of this class in bytes.
+ * Return the memory consumption of this class in bytes.
*/
virtual std::size_t memory_consumption() const;
const BlockVector &v);
/**
- * Returns the state of the vector, i.e., whether compress() needs to be
+ * Return the state of the vector, i.e., whether compress() needs to be
* called after an operation requiring data exchange. Does only return
* non-true values when used in <tt>debug</tt> mode, since it is quite
* expensive to keep track of all operations that lead to the need for
bool is_compressed () const DEAL_II_DEPRECATED;
/**
- * Returns if this Vector contains ghost elements.
+ * Return if this Vector contains ghost elements.
*
* @see
* @ref GlossGhostedVector "vectors with ghost elements"
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format and puts
+ * Set the additional data field to the desired output format and puts
* the restart parameter in case the derived class is GMRES.
*
* TODO: Find a better way for setting the GMRES restart parameter since
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format.
+ * Set the additional data field to the desired output format.
*/
explicit
AdditionalData (const bool output_solver_details = false);
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format.
+ * Set the additional data field to the desired output format.
*/
explicit
AdditionalData (const bool output_solver_details = false);
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format.
+ * Set the additional data field to the desired output format.
*/
explicit
AdditionalData (const bool output_solver_details = false);
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format.
+ * Set the additional data field to the desired output format.
*/
explicit
AdditionalData (const bool output_solver_details = false);
struct AdditionalData
{
/**
- * Sets the additional data field to the desired output format.
+ * Set the additional data field to the desired output format.
*/
explicit
AdditionalData (const bool output_solver_details = false,
unsigned int row_length (const size_type row) const;
/**
- * Returns the state of the matrix, i.e., whether compress() needs to be
+ * Return the state of the matrix, i.e., whether compress() needs to be
* called after an operation requiring data exchange. A call to compress()
* is also needed when the method set() has been called (even when working
* in serial).
//@{
/**
- * Returns the state of the sparsity pattern, i.e., whether compress()
+ * Return the state of the sparsity pattern, i.e., whether compress()
* needs to be called after an operation requiring data exchange.
*/
bool is_compressed () const;
Vector &operator= (const TrilinosScalar s);
/**
- * Sets the left hand argument to the (parallel) Trilinos Vector.
+ * Set the left hand argument to the (parallel) Trilinos Vector.
* Equivalent to the @p reinit function.
*/
Vector &operator= (const MPI::Vector &v);
/**
- * Sets the left hand argument to the deal.II vector.
+ * Set the left hand argument to the deal.II vector.
*/
template <typename Number>
Vector &operator= (const ::dealii::Vector<Number> &v);
void compress (::dealii::VectorOperation::values operation);
/**
- * Returns the state of the vector, i.e., whether compress() has already
+ * Return the state of the vector, i.e., whether compress() has already
* been called after an operation requiring data exchange.
*
* This function is deprecated.
//@{
/**
- * Returns true if the given global index is in the local range of this
+ * Return true if the given global index is in the local range of this
* processor. Since this is not a distributed vector the method always
* returns true.
*/
DoFInfo (const DoFInfo &dof_info);
/**
- * Clears all data fields in this class.
+ * Clear all data fields in this class.
*/
void clear ();
/**
- * Returns a pointer to the first index in the DoF row @p row.
+ * Return a pointer to the first index in the DoF row @p row.
*/
const unsigned int *begin_indices (const unsigned int row) const;
/**
- * Returns a pointer to the one past the last DoF index in the row @p
+ * Return a pointer to the one past the last DoF index in the row @p
* row.
*/
const unsigned int *end_indices (const unsigned int row) const;
/**
- * Returns the number of entries in the indices field for the given row.
+ * Return the number of entries in the indices field for the given row.
*/
unsigned int row_length_indices (const unsigned int row) const;
/**
- * Returns a pointer to the first constraint indicator in the row @p
+ * Return a pointer to the first constraint indicator in the row @p
* row.
*/
const std::pair<unsigned short,unsigned short> *
begin_indicators (const unsigned int row) const;
/**
- * Returns a pointer to the one past the last constraint indicator in
+ * Return a pointer to the one past the last constraint indicator in
* the row @p row.
*/
const std::pair<unsigned short,unsigned short> *
end_indicators (const unsigned int row) const;
/**
- * Returns the number of entries in the constraint indicator field for
+ * Return the number of entries in the constraint indicator field for
* the given row.
*/
unsigned int row_length_indicators (const unsigned int row) const;
/**
- * Returns a pointer to the first index in the DoF row @p row for plain
+ * Return a pointer to the first index in the DoF row @p row for plain
* indices (i.e., the entries where constraints are not embedded).
*/
const unsigned int *begin_indices_plain (const unsigned int row) const;
/**
- * Returns a pointer to the one past the last DoF index in the row @p
+ * Return a pointer to the one past the last DoF index in the row @p
* row (i.e., the entries where constraints are not embedded).
*/
const unsigned int *end_indices_plain (const unsigned int row) const;
/**
- * Returns the FE index for a given finite element degree. If not in hp
+ * Return the FE index for a given finite element degree. If not in hp
* mode, this function always returns index 0. If an index is not found
* in hp mode, it returns max_fe_degree, i.e., one index past the last
* valid one.
/**
- * Returns the FE index for a given finite element degree. If not in hp
+ * Return the FE index for a given finite element degree. If not in hp
* mode or if the index is not found, this function always returns index
* 0. Hence, this function does not check whether the given degree is
* actually present.
std::vector<unsigned int> &irregular_cells);
/**
- * Computes the initial renumbering of cells such that all cells with
+ * Compute the initial renumbering of cells such that all cells with
* ghosts are put first. This is the first step before building the
* thread graph and used to overlap computations and communication.
*/
void renumber_dofs (std::vector<types::global_dof_index> &renumbering);
/**
- * Returns the memory consumption in bytes of this class.
+ * Return the memory consumption in bytes of this class.
*/
std::size_t memory_consumption() const;
unsigned int get_cell_data_number() const;
/**
- * Returns the type of the cell the @p reinit function has been called for.
+ * Return the type of the cell the @p reinit function has been called for.
* Valid values are @p cartesian for Cartesian cells (which allows for
* considerable data compression), @p affine for cells with affine mappings,
* and @p general for general cells without any compressed storage applied.
internal::MatrixFreeFunctions::CellType get_cell_type() const;
/**
- * Returns a reference to the ShapeInfo object currently in use.
+ * Return a reference to the ShapeInfo object currently in use.
*/
const internal::MatrixFreeFunctions::ShapeInfo<Number> &
get_shape_info() const;
const unsigned int first_index=0) const;
/**
- * Writes data to several vectors. Same as other function with std::vector,
+ * Write data to several vectors. Same as other function with std::vector,
* but accepts a vector of pointers to vectors.
*/
template<typename VectorType>
const unsigned int first_index=0) const;
/**
- * Writes data to several vectors. Same as other function with std::vector,
+ * Write data to several vectors. Same as other function with std::vector,
* but accepts a vector of pointers to vectors.
*/
template<typename VectorType>
*/
//@{
/**
- * Returns the value stored for the local degree of freedom with index @p
+ * Return the value stored for the local degree of freedom with index @p
* dof. If the object is vector-valued, a vector-valued return argument is
* given. Note that when vectorization is enabled, values from several cells
* are grouped together. If @p set_dof_values was called last, the value
const unsigned int dof);
/**
- * Returns the value of a finite element function at quadrature point number
+ * Return the value of a finite element function at quadrature point number
* @p q_point after a call to @p evaluate(true,...), or the value that has
* been stored there with a call to @p submit_value. If the object is
* vector-valued, a vector-valued return argument is given. Note that when
const unsigned int q_point);
/**
- * Returns the gradient of a finite element function at quadrature point
+ * Return the gradient of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true,...), or the value
* that has been stored there with a call to @p submit_gradient.
*
const unsigned int q_point);
/**
- * Returns the Hessian of a finite element function at quadrature point
+ * Return the Hessian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true). If only the
* diagonal or even the trace of the Hessian, the Laplacian, is needed, use
* the other functions below.
get_hessian (const unsigned int q_point) const;
/**
- * Returns the diagonal of the Hessian of a finite element function at
+ * Return the diagonal of the Hessian of a finite element function at
* quadrature point number @p q_point after a call to @p evaluate(...,true).
*
* Note that the derived class FEEvaluationAccess overloads this operation
gradient_type get_hessian_diagonal (const unsigned int q_point) const;
/**
- * Returns the Laplacian (i.e., the trace of the Hessian) of a finite
+ * Return the Laplacian (i.e., the trace of the Hessian) of a finite
* element function at quadrature point number @p q_point after a call to @p
* evaluate(...,true). Compared to the case when computing the full Hessian,
* some operations can be saved when only the Laplacian is requested.
*/
//@{
/**
- * Returns a read-only pointer to the first field of the dof values. This is
+ * Return a read-only pointer to the first field of the dof values. This is
* the data field the read_dof_values() functions write into. First come the
* the dof values for the first component, then all values for the second
* component, and so on. This is related to the internal data structures
const VectorizedArray<Number> *begin_dof_values () const;
/**
- * Returns a read and write pointer to the first field of the dof values.
+ * Return a read and write pointer to the first field of the dof values.
* This is the data field the read_dof_values() functions write into. First
* come the the dof values for the first component, then all values for the
* second component, and so on. This is related to the internal data
VectorizedArray<Number> *begin_dof_values ();
/**
- * Returns a read-only pointer to the first field of function values on
+ * Return a read-only pointer to the first field of function values on
* quadrature points. First come the function values on all quadrature
* points for the first component, then all values for the second component,
* and so on. This is related to the internal data structures used in this
const VectorizedArray<Number> *begin_values () const;
/**
- * Returns a read and write pointer to the first field of function values on
+ * Return a read and write pointer to the first field of function values on
* quadrature points. First come the function values on all quadrature
* points for the first component, then all values for the second component,
* and so on. This is related to the internal data structures used in this
VectorizedArray<Number> *begin_values ();
/**
- * Returns a read-only pointer to the first field of function gradients on
+ * Return a read-only pointer to the first field of function gradients on
* quadrature points. First comes the x-component of the gradient for the
* first component on all quadrature points, then the y-component, and so
* on. Next comes the x-component of the second component, and so on. This
const VectorizedArray<Number> *begin_gradients () const;
/**
- * Returns a read and write pointer to the first field of function gradients
+ * Return a read and write pointer to the first field of function gradients
* on quadrature points. First comes the x-component of the gradient for the
* first component on all quadrature points, then the y-component, and so
* on. Next comes the x-component of the second component, and so on. This
VectorizedArray<Number> *begin_gradients ();
/**
- * Returns a read-only pointer to the first field of function hessians on
+ * Return a read-only pointer to the first field of function hessians on
* quadrature points. First comes the xx-component of the hessian for the
* first component on all quadrature points, then the yy-component, zz-
* component in (3D), then the xy-component, and so on. Next comes the xx-
const VectorizedArray<Number> *begin_hessians () const;
/**
- * Returns a read and write pointer to the first field of function hessians
+ * Return a read and write pointer to the first field of function hessians
* on quadrature points. First comes the xx-component of the hessian for the
* first component on all quadrature points, then the yy-component, zz-
* component in (3D), then the xy-component, and so on. Next comes the xx-
VectorizedArray<Number> *begin_hessians ();
/**
- * Returns the numbering of local degrees of freedom within the evaluation
+ * Return the numbering of local degrees of freedom within the evaluation
* routines of FEEvaluation in terms of the standard numbering on finite
* elements.
*/
typedef FEEvaluationBase<dim,1,Number> BaseClass;
/**
- * Returns the value stored for the local degree of freedom with index @p
+ * Return the value stored for the local degree of freedom with index @p
* dof. If the object is vector-valued, a vector-valued return argument is
* given. Note that when vectorization is enabled, values from several cells
* are grouped together. If @p set_dof_values was called last, the value
const unsigned int dof);
/**
- * Returns the value of a finite element function at quadrature point number
+ * Return the value of a finite element function at quadrature point number
* @p q_point after a call to @p evaluate(true,...), or the value that has
* been stored there with a call to @p submit_value. If the object is
* vector-valued, a vector-valued return argument is given. Note that when
const unsigned int q_point);
/**
- * Returns the gradient of a finite element function at quadrature point
+ * Return the gradient of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true,...), or the value
* that has been stored there with a call to @p submit_gradient.
*/
const unsigned int q_point);
/**
- * Returns the Hessian of a finite element function at quadrature point
+ * Return the Hessian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true). If only the
* diagonal part of the Hessian or its trace, the Laplacian, are needed, use
* the respective functions below.
get_hessian (unsigned int q_point) const;
/**
- * Returns the diagonal of the Hessian of a finite element function at
+ * Return the diagonal of the Hessian of a finite element function at
* quadrature point number @p q_point after a call to @p evaluate(...,true).
*/
gradient_type get_hessian_diagonal (const unsigned int q_point) const;
/**
- * Returns the Laplacian of a finite element function at quadrature point
+ * Return the Laplacian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true).
*/
value_type get_laplacian (const unsigned int q_point) const;
typedef FEEvaluationBase<dim,dim,Number> BaseClass;
/**
- * Returns the gradient of a finite element function at quadrature point
+ * Return the gradient of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true,...).
*/
gradient_type get_gradient (const unsigned int q_point) const;
/**
- * Returns the divergence of a vector-valued finite element at quadrature
+ * Return the divergence of a vector-valued finite element at quadrature
* point number @p q_point after a call to @p evaluate(...,true,...).
*/
VectorizedArray<Number> get_divergence (const unsigned int q_point) const;
/**
- * Returns the symmetric gradient of a vector-valued finite element at
+ * Return the symmetric gradient of a vector-valued finite element at
* quadrature point number @p q_point after a call to @p
* evaluate(...,true,...). It corresponds to <tt>0.5
* (grad+grad<sup>T</sup>)</tt>.
get_symmetric_gradient (const unsigned int q_point) const;
/**
- * Returns the curl of the vector field, $nabla \times v$ after a call to @p
+ * Return the curl of the vector field, $nabla \times v$ after a call to @p
* evaluate(...,true,...).
*/
Tensor<1,(dim==2?1:dim),VectorizedArray<Number> >
get_curl (const unsigned int q_point) const;
/**
- * Returns the Hessian of a finite element function at quadrature point
+ * Return the Hessian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true). If only the
* diagonal of the Hessian or its trace, the Laplacian, is needed, use the
* respective functions.
get_hessian (const unsigned int q_point) const;
/**
- * Returns the diagonal of the Hessian of a finite element function at
+ * Return the diagonal of the Hessian of a finite element function at
* quadrature point number @p q_point after a call to @p evaluate(...,true).
*/
gradient_type get_hessian_diagonal (const unsigned int q_point) const;
typedef FEEvaluationBase<1,1,Number> BaseClass;
/**
- * Returns the value stored for the local degree of freedom with index @p
+ * Return the value stored for the local degree of freedom with index @p
* dof. If the object is vector-valued, a vector-valued return argument is
* given. Note that when vectorization is enabled, values from several cells
* are grouped together. If @p set_dof_values was called last, the value
const unsigned int dof);
/**
- * Returns the value of a finite element function at quadrature point number
+ * Return the value of a finite element function at quadrature point number
* @p q_point after a call to @p evaluate(true,...), or the value that has
* been stored there with a call to @p submit_value. If the object is
* vector-valued, a vector-valued return argument is given. Note that when
const unsigned int q_point);
/**
- * Returns the gradient of a finite element function at quadrature point
+ * Return the gradient of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true,...), or the value
* that has been stored there with a call to @p submit_gradient.
*/
const unsigned int q_point);
/**
- * Returns the Hessian of a finite element function at quadrature point
+ * Return the Hessian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true). If only the
* diagonal part of the Hessian or its trace, the Laplacian, are needed, use
* the respective functions below.
get_hessian (unsigned int q_point) const;
/**
- * Returns the diagonal of the Hessian of a finite element function at
+ * Return the diagonal of the Hessian of a finite element function at
* quadrature point number @p q_point after a call to @p evaluate(...,true).
*/
gradient_type get_hessian_diagonal (const unsigned int q_point) const;
/**
- * Returns the Laplacian of a finite element function at quadrature point
+ * Return the Laplacian of a finite element function at quadrature point
* number @p q_point after a call to @p evaluate(...,true).
*/
value_type get_laplacian (const unsigned int q_point) const;
const bool integrate_grad);
/**
- * Returns the q-th quadrature point stored in MappingInfo.
+ * Return the q-th quadrature point stored in MappingInfo.
*/
Point<dim,VectorizedArray<Number> >
quadrature_point (const unsigned int q_point) const;
void check_template_arguments(const unsigned int fe_no);
/**
- * Sets the pointers of the base class to my_data_array.
+ * Set the pointers of the base class to my_data_array.
*/
void set_data_pointers();
TaskInfo ();
/**
- * Clears all the data fields and resets them to zero.
+ * Clear all the data fields and resets them to zero.
*/
void clear ();
/**
- * Returns the memory consumption of the class.
+ * Return the memory consumption of the class.
*/
std::size_t memory_consumption () const;
SizeInfo ();
/**
- * Clears all data fields and resets the sizes to zero.
+ * Clear all data fields and resets the sizes to zero.
*/
void clear();
void reinit(typename dealii::Triangulation<dim>::cell_iterator cell);
/**
- * Returns whether reinit() has been called at least once, i.e., a cell
+ * Return whether reinit() has been called at least once, i.e., a cell
* has been set.
*/
bool is_initialized() const;
MappingInfo();
/**
- * Computes the information in the given cells. The cells are specified
+ * Compute the information in the given cells. The cells are specified
* by the level and the index within the level (as given by
* CellIterator::level() and CellIterator::index(), in order to allow
* for different kinds of iterators, e.g. standard DoFHandler,
std::vector<dealii::hp::QCollection<1> >());
/**
- * Returns the type of a given cell as detected during initialization.
+ * Return the type of a given cell as detected during initialization.
*/
CellType get_cell_type (const unsigned int cell_chunk_no) const;
/**
- * Returns the type of a given cell as detected during initialization.
+ * Return the type of a given cell as detected during initialization.
*/
unsigned int get_cell_data_index (const unsigned int cell_chunk_no) const;
/**
- * Clears all data fields in this class.
+ * Clear all data fields in this class.
*/
void clear ();
/**
- * Returns the memory consumption of this class in bytes.
+ * Return the memory consumption of this class in bytes.
*/
std::size_t memory_consumption() const;
std::vector<unsigned int> quad_index_conversion;
/**
- * Returns the quadrature index for a given number of quadrature
+ * Return the quadrature index for a given number of quadrature
* points. If not in hp mode or if the index is not found, this
* function always returns index 0. Hence, this function does not
* check whether the given degree is actually present.
const SizeInfo &size_info) const;
/**
- * Returns the memory consumption in bytes.
+ * Return the memory consumption in bytes.
*/
std::size_t memory_consumption () const;
};
{};
/**
- * Sets the MPI communicator that the parallel layout of the operator
+ * Set the MPI communicator that the parallel layout of the operator
* should be based upon. Defaults to MPI_COMM_SELF, but should be set to a
* communicator similar to the one used for a distributed triangulation in
* order to inform this class over all cells that are present.
MPI_Comm mpi_communicator;
/**
- * Sets the scheme for task parallelism. There are four options available.
+ * Set the scheme for task parallelism. There are four options available.
* If set to @p none, the operator application is done in serial without
* shared memory parallelism. If this class is used together with MPI and
* MPI is also used for parallelism within the nodes, this flag should be
TasksParallelScheme tasks_parallel_scheme;
/**
- * Sets the number of so-called macro cells that should form one
+ * Set the number of so-called macro cells that should form one
* partition. If zero size is given, the class tries to find a good size
* for the blocks based on MultithreadInfo::n_threads() and the number of
* cells present. Otherwise, the given number is used. If the given number
void copy_from (const MatrixFree<dim,Number> &matrix_free_base);
/**
- * Clears all data fields and brings the class into a condition similar to
+ * Clear all data fields and brings the class into a condition similar to
* after having called the default constructor.
*/
void clear();
const unsigned int vector_component=0) const;
/**
- * Returns the partitioner that represents the locally owned data and the
+ * Return the partitioner that represents the locally owned data and the
* ghost indices where access is needed to for the cell loop. The
* partitioner is constructed from the locally owned dofs and ghost dofs
* given by the respective fields. If you want to have specific information
get_vector_partitioner (const unsigned int vector_component=0) const;
/**
- * Returns the set of cells that are oned by the processor.
+ * Return the set of cells that are oned by the processor.
*/
const IndexSet &
get_locally_owned_set (const unsigned int fe_component = 0) const;
/**
- * Returns the set of ghost cells needed but not owned by the processor.
+ * Return the set of ghost cells needed but not owned by the processor.
*/
const IndexSet &
get_ghost_set (const unsigned int fe_component = 0) const;
/**
- * Returns a list of all degrees of freedom that are constrained. The list
+ * Return a list of all degrees of freedom that are constrained. The list
* is returned in MPI-local index space for the locally owned range of the
* vector, not in global MPI index space that spans all MPI processors. To
* get numbers in global index space, call
*/
//@{
/**
- * Returns the number of different DoFHandlers specified at initialization.
+ * Return the number of different DoFHandlers specified at initialization.
*/
unsigned int n_components () const;
/**
- * Returns the number of cells this structure is based on. If you are using
+ * Return the number of cells this structure is based on. If you are using
* a usual DoFHandler, it corresponds to the number of (locally owned)
* active cells. Note that most data structures in this class do not
* directly act on this number but rather on n_macro_cells() which gives the
unsigned int n_physical_cells () const;
/**
- * Returns the number of macro cells that this structure works on, i.e., the
+ * Return the number of macro cells that this structure works on, i.e., the
* number of cell chunks that are worked on after the application of
* vectorization which in general works on several cells at once. The cell
* range in @p cell_loop runs from zero to n_macro_cells() (exclusive), so
n_components_filled (const unsigned int macro_cell_number) const;
/**
- * Returns the number of degrees of freedom per cell for a given hp index.
+ * Return the number of degrees of freedom per cell for a given hp index.
*/
unsigned int
get_dofs_per_cell (const unsigned int fe_component = 0,
const unsigned int hp_active_fe_index = 0) const;
/**
- * Returns the number of quadrature points per cell for a given hp index.
+ * Return the number of quadrature points per cell for a given hp index.
*/
unsigned int
get_n_q_points (const unsigned int quad_index = 0,
const unsigned int hp_active_fe_index = 0) const;
/**
- * Returns the number of degrees of freedom on each face of the cell for
+ * Return the number of degrees of freedom on each face of the cell for
* given hp index.
*/
unsigned int
const unsigned int hp_active_fe_index = 0) const;
/**
- * Returns the number of quadrature points on each face of the cell for
+ * Return the number of quadrature points on each face of the cell for
* given hp index.
*/
unsigned int
const unsigned int hp_active_fe_index = 0) const;
/**
- * Returns the quadrature rule for given hp index.
+ * Return the quadrature rule for given hp index.
*/
const Quadrature<dim> &
get_quadrature (const unsigned int quad_index = 0,
const unsigned int hp_active_fe_index = 0) const;
/**
- * Returns the quadrature rule for given hp index.
+ * Return the quadrature rule for given hp index.
*/
const Quadrature<dim-1> &
get_face_quadrature (const unsigned int quad_index = 0,
bool mapping_initialized () const;
/**
- * Returns an approximation of the memory consumption of this class in
+ * Return an approximation of the memory consumption of this class in
* bytes.
*/
std::size_t memory_consumption() const;
*/
//@{
/**
- * Returns information on task graph.
+ * Return information on task graph.
*/
const internal::MatrixFreeFunctions::TaskInfo &
get_task_info () const;
/**
- * Returns information on system size.
+ * Return information on system size.
*/
const internal::MatrixFreeFunctions::SizeInfo &
get_size_info () const;
/*
- * Returns geometry-dependent information on the cells.
+ * Return geometry-dependent information on the cells.
*/
const internal::MatrixFreeFunctions::MappingInfo<dim,Number> &
get_mapping_info () const;
/**
- * Returns information on indexation degrees of freedom.
+ * Return information on indexation degrees of freedom.
*/
const internal::MatrixFreeFunctions::DoFInfo &
get_dof_info (const unsigned int fe_component = 0) const;
/**
- * Returns the number of weights in the constraint pool.
+ * Return the number of weights in the constraint pool.
*/
unsigned int n_constraint_pool_entries() const;
/**
- * Returns a pointer to the first number in the constraint pool data with
+ * Return a pointer to the first number in the constraint pool data with
* index @p pool_index (to be used together with @p constraint_pool_end()).
*/
const Number *
constraint_pool_begin (const unsigned int pool_index) const;
/**
- * Returns a pointer to one past the last number in the constraint pool data
+ * Return a pointer to one past the last number in the constraint pool data
* with index @p pool_index (to be used together with @p
* constraint_pool_begin()).
*/
constraint_pool_end (const unsigned int pool_index) const;
/**
- * Returns the unit cell information for given hp index.
+ * Return the unit cell information for given hp index.
*/
const internal::MatrixFreeFunctions::ShapeInfo<Number> &
get_shape_info (const unsigned int fe_component = 0,
const unsigned int base_element = 0);
/**
- * Returns the memory consumption of this class in bytes.
+ * Return the memory consumption of this class in bytes.
*/
std::size_t memory_consumption () const;
unsigned int dofs_per_face;
/**
- * Checks whether we have symmetries in the shape values. In that case,
+ * Check whether we have symmetries in the shape values. In that case,
* also fill the shape_???_evenodd fields.
*/
bool check_1d_shapes_symmetric(const unsigned int n_q_points_1d);
/**
- * Checks whether symmetric 1D basis functions are such that the shape
+ * Check whether symmetric 1D basis functions are such that the shape
* values form a diagonal matrix, which allows to use specialized
* algorithms that save some operations.
*/
bool empty () const;
/**
- * Returns true if values are selected for any vector.
+ * Return true if values are selected for any vector.
*/
bool has_values () const;
/**
- * Returns true if gradients are selected for any vector.
+ * Return true if gradients are selected for any vector.
*/
bool has_gradients () const;
/**
- * Returns true if hessians are selected for any vector.
+ * Return true if hessians are selected for any vector.
*/
bool has_hessians () const;
const VectorType &src) const;
/**
- * Sets the matrix. This gives the possibility to replace the matrix that
+ * Set the matrix. This gives the possibility to replace the matrix that
* was given to the constructor by a new matrix.
*/
template <typename MatrixType>
const unsigned int component = 0);
/**
- * Calls the @p interpolate function, see above, with
+ * Call the @p interpolate function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
const unsigned int component = 0);
/**
- * Calls the @p interpolate function, see above, with
+ * Call the @p interpolate function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
const Strategy strategy = cell_diameter_over_24);
/**
- * Calls the @p estimate function, see above, with
+ * Call the @p estimate function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <typename InputVector, typename DoFHandlerType>
const Strategy strategy = cell_diameter_over_24);
/**
- * Calls the @p estimate function, see above, with
+ * Call the @p estimate function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <typename InputVector, typename DoFHandlerType>
const types::material_id material_id = numbers::invalid_material_id);
/**
- * Calls the @p estimate function, see above, with
+ * Call the @p estimate function, see above, with
* <tt>mapping=MappingQGeneric1<1>()</tt>.
*/
template <typename InputVector, typename DoFHandlerType>
const types::material_id material_id = numbers::invalid_material_id);
/**
- * Calls the @p estimate function, see above, with
+ * Call the @p estimate function, see above, with
* <tt>mapping=MappingQGeneric1<1>()</tt>.
*/
template <typename InputVector, typename DoFHandlerType>
const ConstraintMatrix &constraints = ConstraintMatrix());
/**
- * Calls the create_mass_matrix() function, see above, with
+ * Call the create_mass_matrix() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
const ConstraintMatrix &constraints = ConstraintMatrix());
/**
- * Calls the create_mass_matrix() function, see above, with
+ * Call the create_mass_matrix() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
/**
- * Calls the create_boundary_mass_matrix() function, see above, with
+ * Call the create_boundary_mass_matrix() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
const ConstraintMatrix &constraints = ConstraintMatrix());
/**
- * Calls the create_laplace_matrix() function, see above, with
+ * Call the create_laplace_matrix() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
const ConstraintMatrix &constraints = ConstraintMatrix());
/**
- * Calls the create_laplace_matrix() function, see above, with
+ * Call the create_laplace_matrix() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
const ComponentMask &component_mask = ComponentMask());
/**
- * Calls the @p interpolate() function above with
+ * Call the @p interpolate() function above with
* <tt>mapping=MappingQGeneric1@<dim>@()</tt>.
*/
template <typename VectorType, typename DoFHandlerType>
const bool project_to_boundary_first = false);
/**
- * Calls the project() function above, with
+ * Call the project() function above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, typename VectorType, int spacedim>
const bool project_to_boundary_first = false);
/**
- * Calls the project() function above, with a collection of $Q_1$ mapping
+ * Call the project() function above, with a collection of $Q_1$ mapping
* objects, i.e., with hp::StaticMappingQ1::mapping_collection.
*/
template <int dim, typename VectorType, int spacedim>
const ComponentMask &component_mask = ComponentMask());
/**
- * Calls the other interpolate_boundary_values() function, see above, with
+ * Call the other interpolate_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
* apply as for the previous function, in particular about the use of the
* component mask and the requires size of the function object.
/**
- * Calls the other interpolate_boundary_values() function, see above, with
+ * Call the other interpolate_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
* apply as for the previous function, in particular about the use of the
* component mask and the requires size of the function object.
const ComponentMask &component_mask = ComponentMask());
/**
- * Calls the other interpolate_boundary_values() function, see above, with
+ * Call the other interpolate_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
* apply as for the previous function, in particular about the use of the
* component mask and the requires size of the function object.
/**
- * Calls the other interpolate_boundary_values() function, see above, with
+ * Call the other interpolate_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>. The same comments
* apply as for the previous function, in particular about the use of the
* component mask and the requires size of the function object.
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
- * Calls the project_boundary_values() function, see above, with
+ * Call the project_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
- * Calls the project_boundary_values() function, see above, with
+ * Call the project_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
*/
template <int dim, int spacedim, typename number>
std::vector<unsigned int> component_mapping = std::vector<unsigned int>());
/**
- * Calls the project_boundary_values() function, see above, with
+ * Call the project_boundary_values() function, see above, with
* <tt>mapping=MappingQGeneric@<dim,spacedim@>(1)</tt>.
*
* @ingroup constraints
Vector<double> &rhs_vector);
/**
- * Calls the create_right_hand_side() function, see above, with
+ * Call the create_right_hand_side() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
Vector<double> &rhs_vector);
/**
- * Calls the create_point_source_vector() function, see above, with
+ * Call the create_point_source_vector() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
Vector<double> &rhs_vector);
/**
- * Calls the create_point_source_vector() function for vector-valued finite
+ * Call the create_point_source_vector() function for vector-valued finite
* elements, see above, with <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, int spacedim>
const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
- * Calls the create_boundary_right_hand_side() function, see above, with
+ * Call the create_boundary_right_hand_side() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*
* @see
const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
/**
- * Calls the create_boundary_right_hand_side() function, see above, with a
+ * Call the create_boundary_right_hand_side() function, see above, with a
* single Q1 mapping as collection. This function therefore will only work
* if the only active fe index in use is zero.
*
const double exponent = 2.);
/**
- * Calls the integrate_difference() function, see above, with
+ * Call the integrate_difference() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, class InVector, class OutVector, int spacedim>
const double exponent = 2.);
/**
- * Calls the integrate_difference() function, see above, with
+ * Call the integrate_difference() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, class InVector, class OutVector, int spacedim>
const unsigned int component);
/**
- * Calls the other compute_mean_value() function, see above, with
+ * Call the other compute_mean_value() function, see above, with
* <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
*/
template <int dim, typename VectorType, int spacedim>
namespace internal
{
/**
- * Returns whether the cell and all of its descendants are locally owned.
+ * Return whether the cell and all of its descendants are locally owned.
*/
template <typename cell_iterator>
bool is_locally_owned(const cell_iterator &cell)
projects / dealii.git / commitdiff