Assignments
Scientific Computing with DEAL.II
Summer 2016

A1: Use Deal.ii to solve the "step-1" example.
Turn in your output file by Tuesday, May 24.

A2: The "step-2" example uses linear elements. It computes a bandwidth before and after reordering the variables. Run this example with linear, quadratic, and cubic elements, recording the number of nonzeros in the matrix, and the bandwidths before and after reordering. Your report should be a table:

                     nonzeros       band before          band after
                                     reordering          reordering

            linear        ???               ???                 ???
            quadratic     ???               ???                 ???
            cubic         ???               ???                 ???

Turn in your report by Tuesday, May 31.

A3: The "step-3" example solves the Poisson equation - del^2 u = 1 in the square, with boundary conditions u=0.
1. Look up the GridGenerator function, and determine how to call it in such a way that it generates an L-shaped region instead of the square.
2. Return to the problem on the square. But now set up and solve the system for which the exact solution is u(x,y)=x^2*y. To do this you must change the right hand side from 1 to -2*y. Look at the calculation of "cell_rhs(i)" in assemble_system(); you must also change the boundary condition from 0 to x^2*y. Look at "interpolate_boundary_values()" which currently uses the ZeroFunction<2>. Look at step-4 to get an idea of how you have to declare a righthandside function and a boundaryvalues function.
Turn in a plot of your solutions to parts 1) and 2) by Tuesday, June 14.

A4: Continue to work with the step-3 example, but now we will look at simple ways to check for convergence as the mesh is refined.

Add the following code to the LaplaceProblem::output_results function:

                std::cout << "Solution at (1/3,1/3): "
                          << VectorTools::point_value (dof_handler, solution,
                                       Point<2>(1./3, 1./3))
                          << std::endl;

Now print out the solution value at (1/3,1/3) for each of 9 global refinement steps. We expect to see a list of values that seem to be converging.

Add the following code to LaplaceProblem::output_results:

                std::cout << "Mean value: "
                          << VectorTools::compute_mean_value (dof_handler,
                                              QGauss<2>(3),
                                              solution,
                                              0)
                          << std::endl;

and use it to make a table of the mean value of the solution over the whole domain, for each of 9 successive refinement steps.

Turn in your tables from parts 1) and 2) by Tuesday, June 28.

A5: The step-5 example reads an external grid file of a circle, which it uses as its initial triangulation. It then repeatedly refines the grid to get better and better solutions. The grid file, which is stored as "circle-grid.inp", uses an old mesh file format called UCD. I want you to see a modern mesh file format associated with the GMSH meshing program.

In the initial "include" section of step-5.cc, insert the following line:
```
              # include <deal.II/grid/grid_out.h>
```

Change step-5 from this:

              for (unsigned int cycle=0; cycle<6; ++cycle)
              {

to this (change 6 to 1, and add three lines of text):

                for (unsigned int cycle=0; cycle<1; ++cycle)
                {
                std::ofstream out ("ucd.eps");
                GridOut grid_out;
                grid_out.write_eps (triangulation, out);

Run step-5, which should create the file "ucd.eps".

Convert the UCD mesh file to GMSH format "circle-grid.msh". The basic format is:

$MeshFormat
2.2 0 8
$EndMeshFormat
$Nodes
??? <-- Number of nodes
 1 x1 y1 z1  <-- Index, x, y, z of first node
 2 x2 y2 z1  <-- Index, x, y, z of second node
 ...
$EndNodes
$Elements
??? <-- Number of elements
 1 3 0 n1 n2 n3 n3  <-- Index, 3, 0, node1, node2, node3, node4
 2 3 0 n1 n2 n3 n4  <-- Index, 3, 0, node1, node2, node3, node4
...
$EndElements

Modify step-5 to read your new input file:

              void Step5<dim>::run ()
              {
                GridIn<dim> grid_in;
                grid_in.attach_triangulation (triangulation);
                std::ifstream input_file("circle-grid.msh");

and change from "read_ucd" to "read_msh":

              grid_in.read_msh ( input_file );

and rename your output file image of the grid:

                std::ofstream out ("msh.eps");
                GridOut grid_out;
                grid_out.write_eps (triangulation, out);

Rerun step-5, which should create the output file "msh.eps".

Turn in the files "circle-grid.msh" and "msh.eps" by Tuesday, June 28. If you have access to the GMSH program, you can view the mesh file directly by the command "gmsh circle-grid.msh" and make a plot using the "Save as" menu item, specifying output as "msh.png".

A6: The step-7 example solves the Helmholtz equation 4 times, using Q1 or Q2 elements, and using global or local refinement.
1. Simplify the program by REMOVING the two global refinement cases (easy). You can then run the program just to check that those cases are gone.
2. Find all the places where the program specifies that the order of the quadrature rule should be 3. Increase these quadrature rule order to 5.
3. Find where the maximum number of solver steps is set to 1000. Increase this to 2000.
4. Your program currently runs two cases, Q1 and Q2 elements. We want to add one more case, with Q3 elements. Modify the main function to include this case. Then make the necessary changes in the rest of the program, where it currently only expects cases Q1 and Q2.
5. If you made all these changes, your program should now run adaptive refinement three times, with Q1, Q2, and Q3 elements. It should create 3 VTK files, and 3 Tex files. And it should print 3 convergence tables in the output file, the last one for the Q3 case.
Give me just the output file from your program run, that is, the text file that lists the convergence results for Q1, Q2 and Q3. Turn this in by Tuesday, July 19.

A7: Use Deal.ii to solve the "step-8" example.
VTK files are created for a sequence of 8 meshes. Plot the solution for the final mesh. Turn in your plot by Tuesday, July 26.

You can return to the D2 2016 web page.

Last revised on 19 July 2016.

Assignments Scientific Computing with DEAL.II Summer 2016

Assignments
Scientific Computing with DEAL.II
Summer 2016