Reference documentation for deal.II version Git 409ee4b167 2020-08-14 09:46:12 -0400
TimeStepBase_Tria_Flags::RefinementFlags< dim > Struct Template Reference

#include <deal.II/numerics/time_dependent.h>

## Public Types

using CorrectionRelaxations = std::vector< std::vector< std::pair< unsigned int, double > >>

## Public Member Functions

RefinementFlags (const unsigned int max_refinement_level=0, const unsigned int first_sweep_with_correction=0, const unsigned int min_cells_for_correction=0, const double cell_number_corridor_top=(1<< dim), const double cell_number_corridor_bottom=1, const CorrectionRelaxations &correction_relaxations=CorrectionRelaxations(), const unsigned int cell_number_correction_steps=0, const bool mirror_flags_to_previous_grid=false, const bool adapt_grids=false)

## Static Public Member Functions

static ::ExceptionBaseExcInvalidValue (double arg1)

## Public Attributes

const unsigned int max_refinement_level

const unsigned int first_sweep_with_correction

const unsigned int min_cells_for_correction

const double cell_number_corridor_top

const double cell_number_corridor_bottom

const std::vector< std::vector< std::pair< unsigned int, double > > > correction_relaxations

const unsigned int cell_number_correction_steps

const bool mirror_flags_to_previous_grid

## Static Public Attributes

static CorrectionRelaxations default_correction_relaxations

## Detailed Description

### template<int dim> struct TimeStepBase_Tria_Flags::RefinementFlags< dim >

This structure is used to tell the TimeStepBase_Tria() class how grids should be refined. Before we explain all the different variables, fist some terminology:

• Correction: after having flagged some cells of the triangulation for following some given criterion, we may want to change the number of flagged cells on this grid according to another criterion that the number of cells may be only a certain fraction more or less then the number of cells on the previous grid. This change of refinement flags will be called "correction" in the sequel.
• Adaption: in order to make the change between one grid and the next not to large, we may want to flag some additional cells on one of the two grids such that there are not too grave differences. This process will be called "adaption".

### Description of flags

• max_refinement_level: Cut the refinement of cells at a given level. This flag does not influence the flagging of cells, so not more cells on the coarser levels are flagged than usual. Rather, the flags are all set, but when it comes to the actual refinement, the maximum refinement level is truncated.

This option is only really useful when you want to compare global refinement with adaptive refinement when you don't want the latter to refine more than the global refinement.

• first_sweep_with_correction: When using cell number correction as defined above, it may be worth while to start with this only in later sweeps, not already in the first one. If this variable is zero, then start with the first sweep, else with a higher one. The rationale for only starting later is that we do not want to block the development of grids at the beginning and only impose restrictions in the sweeps where we start to be interested in the actual results of the computations.

• min_cells_for_correction: If we want a more free process of grid development, we may want to impose less rules for grids with few cells also. This variable sets a lower bound for the cell number of grids where corrections are to be performed.

• cell_number_corridor_top: Fraction of the number of cells by which the number of cells of one grid may be higher than that on the previous grid. Common values are 10 per cent (i.e. 0.1). The naming of the variable results from the goal to define a target corridor for the number of cells after refinement has taken place.

• cell_number_corridor_bottom: Fraction of the number of cells by which the number of cells of one grid may be lower than that on the previous grid. Common values are 5 per cent (i.e. 0.05). Usually this number will be smaller than cell_number_corridor_top since an increase of the number of cells is not harmful (though it increases the numerical amount of work needed to solve the problem) while a sharp decrease may reduce the accuracy of the final result even if the time steps computed before the decrease were computed to high accuracy.

Note however, that if you compute the dual problem as well, then the time direction is reversed, so the two values defining the cell number corridor should be about equal.

• correction_relaxations: This is a list of pairs of number with the following meaning: just as for min_cells_for_correction, it may be worth while to reduce the requirements upon grids if the have few cells. The present variable stores a list of cell numbers along with some values which tell us that the cell number corridor should be enlarged by a certain factor. For example, if this list was ((100 5) (200 3) (500 2)), this would mean that for grids with a cell number below 100, the cell_number_corridor_* variables are to be multiplied by 5 before they are applied, for cell numbers below 200 they are to be multiplied by 3, and so on.

correction_relaxations is actually a vector of such list. Each entry in this vector denotes the relaxation rules for one sweep. The last entry defines the relaxation rules for all following sweeps. This scheme is adopted to allow for stricter corrections in later sweeps while the relaxations may be more generous in the first sweeps.

There is a static variable default_correction_relaxations which you can use as a default value. It is an empty list and thus defines no relaxations.

• cell_number_correction_steps: Usually, if you want the number of cells to be corrected, the target corridor for the cell number is computed and some additional cells are flagged or flags are removed. But since the cell number resulting after flagging and deflagging can not be easily computed, it will usually not be within the corridor. We therefore need to iteratively get to our goal. Usually, three or four iterations are needed, but using this variable, you can reduce the allowed number of iterations; breaking the loop after two iterations yields good results regularly. Setting the variable to zero will result in no correction steps at all.

• mirror_flags_to_previous_grid: If a cell on the present grid is flagged for refinement, also flag the corresponding cell on the previous grid. This is useful if, for example, error indicators are computed for space-time cells, but are stored for the second grid only. Now, since the first grid has the same contributions to the indicators as the second, it may be useful to flag both if necessary. This is done if the present variable is set.

• adapt_grids: adapt the present grid to the previous one in the sense defined above. What is actually done here is the following: if going from the previous to the present grid would result in double refinement or double coarsening of some cells, then we try to flag these cells for refinement or coarsening such as to avoid the double step. Obviously, more than double refinement of coarsening is also caught.

Grid adaption can try to avoid such changes between two grids, but it can never promise that they don't occur. This is because the next grid may change the present one, but then again there may be jumps in refinement level between the present and the previous one; this could only be avoided by looping iteratively through all grids, back and forth, until nothing changes anymore, which is obviously impossible if there are many time steps with very large grids.

Definition at line 1131 of file time_dependent.h.

## ◆ CorrectionRelaxations

template<int dim>
 using TimeStepBase_Tria_Flags::RefinementFlags< dim >::CorrectionRelaxations = std::vector >>

Typedef of a data type describing some relaxations of the correction process. See the general description of this class for more information.

Definition at line 1139 of file time_dependent.h.

## ◆ RefinementFlags()

template<int dim>
 TimeStepBase_Tria_Flags::RefinementFlags< dim >::RefinementFlags ( const unsigned int max_refinement_level = 0, const unsigned int first_sweep_with_correction = 0, const unsigned int min_cells_for_correction = 0, const double cell_number_corridor_top = (1 << dim), const double cell_number_corridor_bottom = 1, const CorrectionRelaxations & correction_relaxations = CorrectionRelaxations(), const unsigned int cell_number_correction_steps = 0, const bool mirror_flags_to_previous_grid = false, const bool adapt_grids = false )

Constructor. The default values are chosen such that almost no restriction on the mesh refinement is imposed.

Definition at line 1199 of file time_dependent.cc.

## ◆ default_correction_relaxations

template<int dim>
 TimeStepBase_Tria_Flags::RefinementFlags< dim >::CorrectionRelaxations TimeStepBase_Tria_Flags::RefinementFlags< dim >::default_correction_relaxations
static

Default values for the relaxations: no relaxations.

Definition at line 1144 of file time_dependent.h.

## ◆ max_refinement_level

template<int dim>
 const unsigned int TimeStepBase_Tria_Flags::RefinementFlags< dim >::max_refinement_level

Maximum level of a cell in the triangulation of a time level. If it is set to zero, then no limit is imposed on the number of refinements a coarse grid cell may undergo. Usually, this field is used, if for some reason you want to limit refinement in an adaptive process, for example to avoid overly large numbers of cells or to compare with grids which have a certain number of refinements.

Definition at line 1169 of file time_dependent.h.

## ◆ first_sweep_with_correction

template<int dim>
 const unsigned int TimeStepBase_Tria_Flags::RefinementFlags< dim >::first_sweep_with_correction

First sweep to perform cell number correction steps on; for sweeps before, cells are only flagged and no number-correction to previous grids is performed.

Definition at line 1176 of file time_dependent.h.

## ◆ min_cells_for_correction

template<int dim>
 const unsigned int TimeStepBase_Tria_Flags::RefinementFlags< dim >::min_cells_for_correction

Apply cell number correction with the previous time level only if there are more than this number of cells.

Definition at line 1183 of file time_dependent.h.

## ◆ cell_number_corridor_top

template<int dim>
 const double TimeStepBase_Tria_Flags::RefinementFlags< dim >::cell_number_corridor_top

Fraction by which the number of cells on a time level may differ from the number on the previous time level (first: top deviation, second: bottom deviation).

Definition at line 1190 of file time_dependent.h.

## ◆ cell_number_corridor_bottom

template<int dim>
 const double TimeStepBase_Tria_Flags::RefinementFlags< dim >::cell_number_corridor_bottom

Definition at line 1195 of file time_dependent.h.

## ◆ correction_relaxations

template<int dim>
 const std::vector > > TimeStepBase_Tria_Flags::RefinementFlags< dim >::correction_relaxations

List of relaxations to the correction step.

Definition at line 1201 of file time_dependent.h.

## ◆ cell_number_correction_steps

template<int dim>
 const unsigned int TimeStepBase_Tria_Flags::RefinementFlags< dim >::cell_number_correction_steps

Number of iterations to be performed to adjust the number of cells on a time level to those on the previous one. Zero means: do no such iteration.

Definition at line 1208 of file time_dependent.h.

## ◆ mirror_flags_to_previous_grid

template<int dim>
 const bool TimeStepBase_Tria_Flags::RefinementFlags< dim >::mirror_flags_to_previous_grid

Flag all cells which are flagged on this timestep for refinement on the previous one also. This is useful in case the error indicator was computed by integration over time-space cells, but are now associated to a grid on a discrete time level. Since the error contribution comes from both grids, however, it is appropriate to refine both grids.

Since the previous grid does not mirror the flags to the one before it, this does not lead to an almost infinite growth of cell numbers. You should use this flag with cell number correction switched on only, however.

Mirroring is done after cell number correction is done, but before grid adaption, so the cell number on this grid is not noticeably influenced by the cells flagged additionally on the previous grid.

Definition at line 1226 of file time_dependent.h.