Introduction

Overview

This example is devoted to anisotropic refinement, which extends to possibilities of local refinement. In most parts, this is a modification of the step-12 tutorial program, we use the same DG method for a linear transport equation. This program will cover the following topics:

Anisotropic refinement: What is the meaning of anisotropic refinement?

Implementation: Necessary modifications of code to work with anisotropically refined meshes.

Jump indicator: A simple indicator for anisotropic refinement in the context of DG methods.

The discretization itself will not be discussed, and neither will implementation techniques not specific to anisotropic refinement used here. Please refer to step-12 for this.

Please note, at the moment of writing this tutorial program, anisotropic refinement is only fully implemented for discontinuous Galerkin Finite Elements. This may later change (or may already have).

Note

While this program is a modification of step-12, it is an adaptation of a version of step-12 written early on in the history of deal.II when the MeshWorker framework wasn't available yet. Consequently, it bears little resemblance to the step-12 as it exists now, apart from the fact that it solves the same equation with the same discretization.

Anisotropic refinement

All the adaptive processes in the preceding tutorial programs were based on isotropic refinement of cells, which cuts all edges in half and forms new cells of these split edges (plus some additional edges, faces and vertices, of course). In deal.II, anisotropic refinement refers to the process of splitting only part of the edges while leaving the others unchanged. Consider a simple square cell, for example:

-------*

| |

| |

| |

-------*

After the usual refinement it will consist of four children and look like this:

All refinement cases of cells are described by an enumeration RefinementPossibilities::Possibilities, and the above anisotropic cases are called cut_x and cut_y for obvious reasons. The isotropic refinement case is called cut_xy in 2D and can be requested from the GeometryInfo class via GeometryInfo<2>::isotropic_refinement.

In 3D, there is a third axis which can be split, the z-axis, and thus we have an additional refinement case cut_z here. Isotropic refinement will now refine a cell along the x-, y- and z-axes and thus be referred to as cut_xyz. Additional cases cut_xy, cut_xz and cut_yz exist, which refine a cell along two of the axes, but not along the third one. Given a hex cell with x-axis running to the right, y-axis 'into the page' and z-axis to the top,

-----------*

/ /|

/ / |

/ / |

-----------* |

| | |

| | *

| | /

| | /

| |/

-----------*

we have the isotropic refinement case,

-----*-----*

/ / /|

-----*-----* |

/ / /| *

-----*-----* |/|

| | | * |

| | |/| *

-----*-----* |/

| | | *

| | |/

-----*-----*

cut_xyz

three anisotropic cases which refine only one axis:

-----*-----* *-----------* *-----------*

/ / /| / /| / /|

/ / / | *-----------* | / / |

/ / / | / /| | / / *

-----*-----* | *-----------* | | *-----------* /|

| | | | | | | | | | / |

| | | * | | | * | |/ *

| | | / | | |/ *-----------* /

| | | / | | * | | /

| | |/ | |/ | |/

-----*-----* *-----------* *-----------*

cut_x cut_y cut_z

and three cases which refine two of the three axes:

-----*-----* *-----*-----* *-----------*

/ / /| / / /| / /|

-----*-----* | / / / | *-----------* |

/ / /| | / / / * / /| *

-----*-----* | | *-----*-----* /| *-----------* |/|

| | | | | | | | / | | | * |

| | | | * | | |/ * | |/| *

| | | |/ *-----*-----* / *-----------* |/

| | | * | | | / | | *

| | |/ | | |/ | |/

-----*-----* *-----*-----* *-----------*

cut_xy cut_xz cut_yz

For 1D problems, anisotropic refinement can make no difference, as there is only one coordinate direction for a cell, so it is not possible to split it in any other way than isotropically.

Motivation

Adaptive local refinement is used to obtain fine meshes which are well adapted to solving the problem at hand efficiently. In short, the size of cells which produce a large error is reduced to obtain a better approximation of the solution to the problem at hand. However, a lot of problems contain anisotropic features. Prominent examples are shocks or boundary layers in compressible viscous flows. An efficient mesh approximates these features with cells of higher aspect ratio which are oriented according to the mentioned features. Using only isotropic refinement, the aspect ratios of the original mesh cells are preserved, as they are inherited by the children of a cell. Thus, starting from an isotropic mesh, a boundary layer will be refined in order to catch the rapid variation of the flow field in the wall normal direction, thus leading to cells with very small edge lengths both in normal and tangential direction. Usually, much higher edge lengths in tangential direction and thus significantly less cells could be used without a significant loss in approximation accuracy. An anisotropic refinement process can modify the aspect ratio from mother to child cells by a factor of two for each refinement step. In the course of several refinements, the aspect ratio of the fine cells can be optimized, saving a considerable number of cells and correspondingly degrees of freedom and thus computational resources, memory as well as CPU time.

Implementation

Most of the time, when we do finite element computations, we only consider one cell at a time, for example to calculate cell contributions to the global matrix, or to interpolate boundary values. However, sometimes we have to look at how cells are related in our algorithms. Relationships between cells come in two forms: neighborship and mother-child relationship. For the case of isotropic refinement, deal.II uses certain conventions (invariants) for cell relationships that are always maintained. For example, a refined cell always has exactly \(2^{dim}\) children. And (except for the 1d case), two neighboring cells may differ by at most one refinement level: they are equally often refined or one of them is exactly once more refined, leaving exactly one hanging node on the common face. Almost all of the time these invariants are only of concern in the internal implementation of the library. However, there are cases where knowledge of them is also relevant to an application program.

In the current context, it is worth noting that the kind of mesh refinement affects some of the most fundamental assumptions. Consequently, some of the usual code found in application programs will need modifications to exploit the features of meshes which were created using anisotropic refinement. For those interested in how deal.II evolved, it may be of interest that the loosening of such invariants required some incompatible changes. For example, the library used to have a member GeometryInfo<dim>::children_per_cell that specified how many children a cell has once it is refined. For isotropic refinement, this number is equal to \(2^{dim}\), as mentioned above. However, for anisotropic refinement, this number does not exist, as is can be either two or four in 2D and two, four or eight in 3D, and the member GeometryInfo<dim>::children_per_cell has consequently been removed. It has now been replaced by GeometryInfo<dim>::max_children_per_cell which specifies the maximum number of children a cell can have. How many children a refined cell has was previously available as static information, but now it depends on the actual refinement state of a cell and can be retrieved using the function call cell->n_children(), a call that works equally well for both isotropic and anisotropic refinement. A very similar situation can be found for faces and their subfaces: the previously available variable GeometryInfo<dim>::subfaces_per_face no longer exists; the pertinent information can now be queried using GeometryInfo<dim>::max_children_per_face or face->n_children(), depending on the context.

Another important aspect, and the most important one in this tutorial, is the treatment of neighbor-relations when assembling jump terms on the faces between cells. Looking at the documentation of the assemble_system functions in step-12 we notice, that we need to decide if a neighboring cell is coarser, finer or on the same (refinement) level as our current cell. These decisions do not work in the same way for anisotropic refinement as the information given by the level of a cell is not enough to completely characterize anisotropic cells; for example, are the terminal children of a two-dimensional cell that is first cut in \(x\)-direction and whose children are then cut in \(y\)-direction on level 2, or are they on level 1 as they would be if the cell would have been refined once isotropically, resulting in the same set of finest cells?

After anisotropic refinement, a coarser neighbor is not necessarily exactly one level below ours, but can pretty much have any level relative to the current one; in fact, it can even be on a higher level even though it is coarser. Thus the decisions have to be made on a different basis, whereas the intention of the decisions stays the same.

In the following, we will discuss the cases that can happen when we want to compute contributions to the matrix (or right hand side) of the form

\[ \int_{\partial K} \varphi_i(x) \varphi_j(x) \; dx \]

or similar; remember that we integrate terms like this using the FEFaceValues and FESubfaceValues classes. We will also show how to write code that works for both isotropic and anisotropic refinement:

Finer neighbor: If we are on an active cell and want to integrate over a face \(f\subset \partial K\), the first possibility is that the neighbor behind this face is more refined, i.e. has children occupying only part of the common face. In this case, the face under consideration has to be a refined one, which can determine by asking if(face->has_children()). If this is true, we need to loop over all subfaces and get the neighbors' child behind this subface, so that we can reinit an FEFaceValues object with the neighbor and an FESubfaceValues object with our cell and the respective subface.

For isotropic refinement, this kind is reasonably simple because we know that an invariant of the isotropically refined adaptive meshes in deal.II is that neighbors can only differ by exactly one refinement level. However, this isn't quite true any more for anisotropically refined meshes, in particular in 3d; there, the active cell we are interested on the other side of \(f\) might not actually be a child of our neighbor, but perhaps a grandchild or even a farther offspring. Fortunately, this complexity is hidden in the internals of the library. All we need to do is call the cell->neighbor_child_on_subface(face_no, subface_no) function. Still, in 3D there are two cases which need special consideration:

If the neighbor is refined more than once anisotropically, it might be that here are not two or four but actually three subfaces to consider. Imagine the following refinement process of the (two-dimensional) face of the (three-dimensional) neighbor cell we are considering: first the face is refined along x, later on only the left subface is refined along y.

-------* *---*---* *---*---*

| | | | | | | |

| | ---> | | | ---> *---* |

| | | | | | | |

-------* *---*---* *---*---*

Here the number of subfaces is three. It is important to note the subtle differences between face->n_children() and face->number_of_children(). The first function returns the number of immediate children, which would be two for the above example, whereas the second returns the number of active offsprings, which is the correct three in the example above. Using face->number_of_children() works for isotropic and anisotropic as well as 2D and 3D cases, so it should always be used. It should be noted that if any of the cells behind the two small subfaces on the left side of the rightmost image is further refined, then the current cell (i.e. the side from which we are viewing this common face) is going to be refined as well: this is so because otherwise the invariant of having only one hanging node per edge would be violated.

It might be, that the neighbor is coarser, but still has children which are finer than our current cell. This situation can occur if two equally coarse cells are refined, where one of the cells has two children at the face under consideration and the other one four. The cells in the next graphic are only separated from each other to show the individual refinement cases.

-----------* *-----------*

/ /| / /|

############# | +++++++++++++ |

# ## | + ++ *

############# # | +++++++++++++ +/|

# # # | + + + |

# # # * + +++ *

# # #/ +++++++++++++ +/

# # # + + +

# ## + ++

############# +++++++++++++

Here, the left two cells resulted from an anisotropic bisection of the mother cell in \(y\)-direction, whereas the right four cells resulted from a simultaneous anisotropic refinement in both the \(y\)- and \(z\)-directions. The left cell marked with # has two finer neighbors marked with +, but the actual neighbor of the left cell is the complete right mother cell, as the two cells marked with + are finer and their direct mother is the one large cell.

However, it is comfortable to know, that cell->neighbor_child_on_subface(face_no,subface_no) takes care of these situations by itself, if you loop over the correct number of subfaces, in the above example this is two. The FESubfaceValues<dim>::reinit function takes care of this too, so that the resulting state is always correct. There is one little aspect, however: For reiniting the neighbors FEFaceValues object you need to know the index of the face that points toward the current cell. Usually you assume that the neighbor you get directly is as coarse or as fine as you, if it has children, thus this information can be obtained by the cell->neighbor_of_neighbor(face_no) function. If the neighbor is coarser, however, you would have to use cell->neighbor_of_coarser_neighbor(face_no).first instead. In order to make this easy for you, there is the new cell->neighbor_face_no(face_no) function which does the correct thing for you and returns the desired result.

Neighbor is as fine as our cell: After we ruled out all cases in which there are finer children, we only need to decide, whether the neighbor is coarser here. For this, there is the cell->coarser_neighbor(face_no) function returning a bool value. In order to get the relevant case of a neighbor of the same coarseness we would use else if (!cell->coarser_neighbor(face_no)). The code inside this block can be left untouched. However, there is one thing to mention here: If we want to use a rule, which cell should assemble certain terms on a given face we might think of the rule presented in step-12. We know that we have to leave out the part about comparing our cell's level with that of the neighbor and replace it with the test for a coarser neighbor presented above. However, we also have to consider the possibility that neighboring cells of same coarseness have the same index (on different levels). Thus we have to include the case where the cells have the same index, and give an additional condition, which of the cells should assemble the terms, e.g. we can choose the cell with lower level. The details of this concept can be seen in the implementation below.

Coarser neighbor: The remaining case is obvious: If there are no refined neighbors and the neighbor is not as fine as the current cell, then it needs to be coarser. Thus we can leave the old condition phrase, simply using else. The cell->neighbor_of_coarser_neighbor(face_no) function takes care of all the complexity of anisotropic refinement combined with possible non standard face orientation, flip and rotation on general 3D meshes.

Mesh smoothing

When a triangulation is refined, cells which were not flagged for refinement may be refined nonetheless. This is due to additional smoothing algorithms which are either necessary or requested explicitly. In particular, the restriction that there be at most one hanging node on each edge frequently forces the refinement of additional cells neighboring ones that are already finer and are flagged for further refinement.

However, deal.II also implements a number of algorithms that make sure that resulting meshes are smoother than just the bare minimum, for example ensuring that there are no isolated refined cells surrounded by non-refined ones, since the additional degrees of freedom on these islands would almost all be constrained by hanging node constraints. (See the documentation of the Triangulation class and its Triangulation::MeshSmoothing member for more information on mesh smoothing.)

Most of the smoothing algorithms that were originally developed for the isotropic case have been adapted to work in a very similar way for both anisotropic and isotropic refinement. There are two algorithms worth mentioning, however:

MeshSmoothing::limit_level_difference_at_vertices: In an isotropic environment, this algorithm tries to ensure a good approximation quality by reducing the difference in refinement level of cells meeting at a common vertex. However, there is no clear corresponding concept for anisotropic refinement, thus this algorithm may not be used in combination with anisotropic refinement. This restriction is enforced by an assertion which throws an error as soon as the algorithm is called on a triangulation which has been refined anisotropically.

MeshSmoothing::allow_anisotropic_smoothing: If refinement is introduced to limit the number of hanging nodes, the additional cells are often not needed to improve the approximation quality. This is especially true for DG methods. If you set the flag allow_anisotropic_smoothing the smoothing algorithm tries to minimize the number of probably unneeded additional cells by using anisotropic refinement for the smoothing. If you set this smoothing flag you might get anisotropically refined cells, even if you never set a single refinement flag to anisotropic refinement. Be aware that you should only use this flag, if your code respects the possibility of anisotropic meshes. Combined with a suitable anisotropic indicator this flag can help save additional cells and thus effort.

Jump indicator

Using the benefits of anisotropic refinement requires an indicator to catch anisotropic features of the solution and exploit them for the refinement process. Generally the anisotropic refinement process will consist of several steps:

Calculate an error indicator.

Use the error indicator to flag cells for refinement, e.g. using a fixed number or fraction of cells. Those cells will be flagged for isotropic refinement automatically.

Evaluate a distinct anisotropic indicator only on the flagged cells.

Use the anisotropic indicator to set a new, anisotropic refinement flag for cells where this is appropriate, leave the flags unchanged otherwise.

This approach is similar to the one we have used in step-27 for hp refinement and has the great advantage of flexibility: Any error indicator can be used in the anisotropic process, i.e. if you have quite involved a posteriori goal-oriented error indicators available you can use them as easily as a simple Kelly error estimator. The anisotropic part of the refinement process is not influenced by this choice. Furthermore, simply leaving out the third and forth steps leads to the same isotropic refinement you used to get before any anisotropic changes in deal.II or your application program. As a last advantage, working only on cells flagged for refinement results in a faster evaluation of the anisotropic indicator, which can become noticeable on finer meshes with a lot of cells if the indicator is quite involved.

Here, we use a very simple approach which is only applicable to DG methods. The general idea is quite simple: DG methods allow the discrete solution to jump over the faces of a cell, whereas it is smooth within each cell. Of course, in the limit we expect that the jumps tend to zero as we refine the mesh and approximate the true solution better and better. Thus, a large jump across a given face indicates that the cell should be refined (at least) orthogonal to that face, whereas a small jump does not lead to this conclusion. It is possible, of course, that the exact solution is not smooth and that it also features a jump. In that case, however, a large jump over one face indicates, that this face is more or less parallel to the jump and in the vicinity of it, thus again we would expect a refinement orthogonal to the face under consideration to be effective.

The proposed indicator calculates the average jump \(K_j\), i.e. the mean value of the absolute jump \(|[u]|\) of the discrete solution \(u\) over the two faces \(f_i^j\), \(i=1,2\), \(j=1..d\) orthogonal to coordinate direction \(j\) on the unit cell.

If the average jump in one direction is larger than the average of the jumps in the other directions by a certain factor \(\kappa\), i.e. if \(K_i > \kappa \frac 1{d-1} \sum_{j=1, j\neq i}^d K_j\), the cell is refined only along that particular direction \(i\), otherwise the cell is refined isotropically.

Such a criterion is easily generalized to systems of equations: the absolute value of the jump would be replaced by an appropriate norm of the vector-valued jump.

The problem

We solve the linear transport equation presented in step-12. The domain is extended to cover \([-1,1]\times[0,1]\) in 2D, where the flow field \(\beta\) describes a counterclockwise quarter circle around the origin in the right half of the domain and is parallel to the x-axis in the left part of the domain. The inflow boundary is again located at \(x=1\) and along the positive part of the x-axis, and the boundary conditions are chosen as in step-12. Compared to step-12 we only use the more effective second assembling technique. In order to make comparisons more effective, we decided to keep function names like assemble_system2 even if there is only one of these routines in this tutorial program.

The commented program

The deal.II include files have already been covered in previous examples and will thus not be further commented on.

The flow field is chosen to be a quarter circle with counterclockwise flow direction and with the origin as midpoint for the right half of the domain with positive \(x\) values, whereas the flow simply goes to the left in the left part of the domain at a velocity that matches the one coming in from the right. In the circular part the magnitude of the flow velocity is proportional to the distance from the origin. This is a difference to step-12, where the magnitude was 1 everywhere. the new definition leads to a linear variation of \(\beta\) along each given face of a cell. On the other hand, the solution \(u(x,y)\) is exactly the same as before.

Likewise, the constructor of the class as well as the functions assembling the terms corresponding to cell interiors and boundary faces are unchanged from before. The function that assembles face terms between cells also did not change because all it does is operate on two objects of type FEFaceValuesBase (which is the base class of both FEFaceValues and FESubfaceValues). Where these objects come from, i.e. how they are initialized, is of no concern to this function: it simply assumes that the quadrature points on faces or subfaces represented by the two objects correspond to the same points in physical space.

Class: DGMethod

Even the main class of this program stays more or less the same. We omit one of the assembly routines and use only the second, more effective one of the two presented in step-12. However, we introduce a new routine (set_anisotropic_flags) and modify another one (refine_grid).

This is new, the threshold value used in the evaluation of the anisotropic jump indicator explained in the introduction. Its value is set to 3.0 in the constructor, but it can easily be changed to a different value greater than 1.

constdouble anisotropic_threshold_ratio;

This is a bool flag indicating whether anisotropic refinement shall be used or not. It is set by the constructor, which takes an argument of the same name.

As beta is a linear function, we can choose the degree of the quadrature for which the resulting integration is correct. Thus, we choose to use degree+1 Gauss points, which enables us to integrate exactly polynomials of degree 2*degree+1, enough for all the integrals we will perform in this program.

We proceed with the assemble_system2 function that implements the DG discretization in its second version. This function is very similar to the assemble_system2 function from step-12, even the four cases considered for the neighbor-relations of a cell are the same, namely a) cell is at the boundary, b) there are finer neighboring cells, c) the neighbor is neither coarser nor finer and d) the neighbor is coarser. However, the way in which we decide upon which case we have are modified in the way described in the introduction.

Case b), we decide that there are finer cells as neighbors by asking the face, whether it has children. if so, then there must also be finer cells which are children or farther offspring of our neighbor.

if (face->has_children())

{

We need to know, which of the neighbors faces points in the direction of our cell. Using the neighbor_face_no function we get this information for both coarser and non-coarser neighbors.

constunsignedint neighbor2=

cell->neighbor_face_no(face_no);

Now we loop over all subfaces, i.e. the children and possibly grandchildren of the current face.

for (unsignedint subface_no=0;

subface_no<face->number_of_children(); ++subface_no)

{

To get the cell behind the current subface we can use the neighbor_child_on_subface function. it takes care of all the complicated situations of anisotropic refinement and non-standard faces.

Case c). We simply ask, whether the neighbor is coarser. If not, then it is neither coarser nor finer, since any finer neighbor would have been treated above with case b). Of all the cases with the same refinement situation of our cell and the neighbor we want to treat only one half, so that each face is considered only once. Thus we have the additional condition, that the cell with the lower index does the work. In the rare case that both cells have the same index, the cell with lower level is selected.

if (!cell->neighbor_is_coarser(face_no) &&

(neighbor->index() > cell->index() ||

(neighbor->level() < cell->level() &&

neighbor->index() == cell->index())))

{

Here we know, that the neighbor is not coarser so we can use the usual neighbor_of_neighbor function. However, we could also use the more general neighbor_face_no function.

Now the refinement flags are set for those cells with a large error indicator. If nothing is done to change this, those cells will be refined isotropically. If the anisotropic flag given to this function is set, we now call the set_anisotropic_flags() function, which uses the jump indicator to reset some of the refinement flags to anisotropic refinement.

if (anisotropic)

set_anisotropic_flags();

Now execute the refinement considering anisotropic as well as isotropic refinement flags.

triangulation.execute_coarsening_and_refinement ();

}

Once an error indicator has been evaluated and the cells with largest error are flagged for refinement we want to loop over the flagged cells again to decide whether they need isotropic refinement or whether anisotropic refinement is more appropriate. This is the anisotropic jump indicator explained in the introduction.

template <int dim>

void DGMethod<dim>::set_anisotropic_flags ()

{

We want to evaluate the jump over faces of the flagged cells, so we need some objects to evaluate values of the solution on faces.

... and reinit the respective FEFaceValues and FESubFaceValues objects.

fe_v_subface.reinit (cell, face_no, subface_no);

fe_v_face_neighbor.reinit (neighbor_child, neighbor2);

We obtain the function values

fe_v_subface.get_function_values(solution2, u);

fe_v_face_neighbor.get_function_values(solution2, u_neighbor);

as well as the quadrature weights, multiplied by the Jacobian determinant.

const std::vector<double> &JxW = fe_v_subface.get_JxW_values ();

Now we loop over all quadrature points

for (unsignedint x=0; x<fe_v_subface.n_quadrature_points; ++x)

{

and integrate the absolute value of the jump of the solution, i.e. the absolute value of the difference between the function value seen from the current cell and the neighboring cell, respectively. We know, that the first two faces are orthogonal to the first coordinate direction on the unit cell, the second two faces are orthogonal to the second coordinate direction and so on, so we accumulate these values into vectors with dim components.

jump[face_no/2]+=std::fabs(u[x]-u_neighbor[x])*JxW[x];

We also sum up the scaled weights to obtain the measure of the face.

area[face_no/2]+=JxW[x];

}

}

}

else

{

if (!cell->neighbor_is_coarser(face_no))

{

Our current cell and the neighbor have the same refinement along the face under consideration. Apart from that, we do much the same as with one of the subcells in the above case.

unsignedint neighbor2=cell->neighbor_of_neighbor(face_no);

fe_v_face.reinit (cell, face_no);

fe_v_face_neighbor.reinit (neighbor, neighbor2);

fe_v_face.get_function_values(solution2, u);

fe_v_face_neighbor.get_function_values(solution2, u_neighbor);

const std::vector<double> &JxW = fe_v_face.get_JxW_values ();

for (unsignedint x=0; x<fe_v_face.n_quadrature_points; ++x)

{

jump[face_no/2]+=std::fabs(u[x]-u_neighbor[x])*JxW[x];

area[face_no/2]+=JxW[x];

}

}

else//i.e. neighbor is coarser than cell

{

Now the neighbor is actually coarser. This case is new, in that it did not occur in the assembly routine. Here, we have to consider it, but this is not overly complicated. We simply use the neighbor_of_coarser_neighbor function, which again takes care of anisotropic refinement and non-standard face orientation by itself.

Now we analyze the size of the mean jumps, which we get dividing the jumps by the measure of the respective faces.

double average_jumps[dim];

double sum_of_average_jumps=0.;

for (unsignedint i=0; i<dim; ++i)

{

average_jumps[i] = jump(i)/area(i);

sum_of_average_jumps += average_jumps[i];

}

Now we loop over the dim coordinate directions of the unit cell and compare the average jump over the faces orthogonal to that direction with the average jumps over faces orthogonal to the remaining direction(s). If the first is larger than the latter by a given factor, we refine only along hat axis. Otherwise we leave the refinement flag unchanged, resulting in isotropic refinement.

Results

The output of this program consist of the console output, the eps files containing the grids, and the grids and solutions given in gnuplot format.

Performing a 2D run with isotropic refinement...

------------------------------------------------

Cycle 0:

Number of active cells: 128

Number of degrees of freedom: 512

Time of assemble_system2: 0.040003

Writing grid to <grid-0.iso.eps>...

Writing grid to <grid-0.iso.gnuplot>...

Writing solution to <sol-0.iso.gnuplot>...

Cycle 1:

Number of active cells: 239

Number of degrees of freedom: 956

Time of assemble_system2: 0.072005

Writing grid to <grid-1.iso.eps>...

Writing grid to <grid-1.iso.gnuplot>...

Writing solution to <sol-1.iso.gnuplot>...

Cycle 2:

Number of active cells: 491

Number of degrees of freedom: 1964

Time of assemble_system2: 0.144009

Writing grid to <grid-2.iso.eps>...

Writing grid to <grid-2.iso.gnuplot>...

Writing solution to <sol-2.iso.gnuplot>...

Cycle 3:

Number of active cells: 1031

Number of degrees of freedom: 4124

Time of assemble_system2: 0.296019

Writing grid to <grid-3.iso.eps>...

Writing grid to <grid-3.iso.gnuplot>...

Writing solution to <sol-3.iso.gnuplot>...

Cycle 4:

Number of active cells: 2027

Number of degrees of freedom: 8108

Time of assemble_system2: 0.576036

Writing grid to <grid-4.iso.eps>...

Writing grid to <grid-4.iso.gnuplot>...

Writing solution to <sol-4.iso.gnuplot>...

Cycle 5:

Number of active cells: 4019

Number of degrees of freedom: 16076

Time of assemble_system2: 1.13607

Writing grid to <grid-5.iso.eps>...

Writing grid to <grid-5.iso.gnuplot>...

Writing solution to <sol-5.iso.gnuplot>...

Performing a 2D run with anisotropic refinement...

--------------------------------------------------

Cycle 0:

Number of active cells: 128

Number of degrees of freedom: 512

Time of assemble_system2: 0.040003

Writing grid to <grid-0.aniso.eps>...

Writing grid to <grid-0.aniso.gnuplot>...

Writing solution to <sol-0.aniso.gnuplot>...

Cycle 1:

Number of active cells: 171

Number of degrees of freedom: 684

Time of assemble_system2: 0.048003

Writing grid to <grid-1.aniso.eps>...

Writing grid to <grid-1.aniso.gnuplot>...

Writing solution to <sol-1.aniso.gnuplot>...

Cycle 2:

Number of active cells: 255

Number of degrees of freedom: 1020

Time of assemble_system2: 0.072005

Writing grid to <grid-2.aniso.eps>...

Writing grid to <grid-2.aniso.gnuplot>...

Writing solution to <sol-2.aniso.gnuplot>...

Cycle 3:

Number of active cells: 397

Number of degrees of freedom: 1588

Time of assemble_system2: 0.16401

Writing grid to <grid-3.aniso.eps>...

Writing grid to <grid-3.aniso.gnuplot>...

Writing solution to <sol-3.aniso.gnuplot>...

Cycle 4:

Number of active cells: 658

Number of degrees of freedom: 2632

Time of assemble_system2: 0.192012

Writing grid to <grid-4.aniso.eps>...

Writing grid to <grid-4.aniso.gnuplot>...

Writing solution to <sol-4.aniso.gnuplot>...

Cycle 5:

Number of active cells: 1056

Number of degrees of freedom: 4224

Time of assemble_system2: 0.304019

Writing grid to <grid-5.aniso.eps>...

Writing grid to <grid-5.aniso.gnuplot>...

Writing solution to <sol-5.aniso.gnuplot>...

This text output shows the reduction in the number of cells which results from the successive application of anisotropic refinement. After the last refinement step the savings have accumulated so much, that almost four times as many cells and thus dofs are needed in the isotropic case. The time needed for assembly scales with a similar factor.

Now we show the solutions on the mesh after one and after five adaptive refinement steps for both the isotropic (left) and anisotropic refinement algorithms (right).

We see, that the solution on the anisotropically refined mesh is very similar to the solution obtained on the isotropically refined mesh. Thus the anisotropic indicator seems to effectively select the appropriate cells for anisotropic refinement. This observation is strengthened by the plot of the an adapted anisotropic grid, e.g. the grid after three refinement steps.

In the whole left part of the domain refinement is only performed along the y-axis of cells. In the right part of the domain the refinement is dominated by isotropic refinement, as the anisotropic feature of the solution - the jump from one to zero - is not well aligned with the mesh. However, at the bottom and leftmost parts of the quarter circle this jumps becomes more and more aligned with the mesh and the refinement algorithm reacts by creating anisotropic cells of increasing aspect ratio.

It might seem that the necessary alignment of anisotropic features and the coarse mesh can decrease performance significantly for real world problems. However, that is not always the case. Considering boundary layers in compressible viscous flows, for example, the mesh is always aligned with the anisotropic features, thus anisotropic refinement will almost always increase the efficiency of computations on adapted grids for these cases.