Enhancement of the code

[sebglane]

Here I am collecting some ideas for an enhancement of the library. The features below can mainly be implemented in the Problem<dim> because all types of problems would benefit from them.

• [x] Implementing a class to handle the boundary conditions. This class should take care of all boundary condition associated with a field. It should also distinguish between the boundary conditions which are time-dependent and those which are not. Moreover, it should check that only one boundary condition is assigned to each boundary. I have implement a basic structure which has these features here (header file) and here (source file). This implementation is based on the one in the adaflo library.

• [x] Implementing adaptive mesh refinement. The problem here is that we have separate DofHandlers which operate on the same mesh. We need to transfer the solution from the coarse to the fine mesh and we need to do this for every entity. I have implemented a mesh refinement method here but this method is hard coded for the specific problem. I think what we want here is a refinement method which takes a list of EntityBase and performs the refinement and the transfer of the solutions. I am thinking of

  
  void refine_mesh(std::vector<EntityBase<dim>> &entities)
  {
  // create solution transfer objects
  create a list of solution transfer objects
  // estimate error
  call to a virtual function
  // prepare the triangulation
  parallel::distributed::
  GridRefinement::refine_and_coarsen_fixed_fraction(triangulation,
                                                  estimated_error_per_cell,
                                                  0.3, 0.3);
  // prepare solution transfer
  triangulation.prepare_coarsening_and_refinement();
  
  operate on the list: solution_transfer[i].prepare_for_coarsening_and_refinement(x[i]);
  
  // refine triangulation
  triangulation.execute_coarsening_and_refinement();

// setup dofs and constraints on refined mesh setup_dofs();

// perform solution transfer operate on the list: std::vector<LA::Vector *> tmp_vectors(3); tmp_vectors[0] = &entities[i].solution; tmp_vectors[1] = &entities[i].old_solution; tmp_vectors[2] = &entities[i].old_old_solution; solution_transfer[i].interpolate(tmp_vectors); }

- [ ] Implement the possibility to resume from a snapshot saved to the filesystem, see [here for the method which loads a snapshot](https://github.com/sebglane/BoussinesqFluidSolver/blob/c61f1c6c885e45c4ac17a1c3f15457072d449fb4/source/buoyant_fluid_solver.cc#L251-#385)  and [here for the method which saves a snapshot](https://github.com/sebglane/BoussinesqFluidSolver/blob/c61f1c6c885e45c4ac17a1c3f15457072d449fb4/source/buoyant_fluid_solver.cc#L196-#248). These implementations again rely on deal.ii's `SolutionTtransfer` class. Therefore, a similar structure regarding `std::vector<EntitiyBase<dim>> to that described in 2. should be possible.
- [x] Implementing graphical output of the solution through one or multiple postprocessors. The computation of additional fields such as the pressure gradient or the vorticity is desirable. This can be achieved in a unified framework through deal.ii's `DataPostprocessor<dim>` class. An example is given [here (header file)](https://github.com/sebglane/BoussinesqFluidSolver/blob/master/include/adsolic/postprocessor.h) and [here (source file)](https://github.com/sebglane/BoussinesqFluidSolver/blob/master/source/postprocessor.cc).

[sebglane]

I think what is left to be done is 3.) and 4.). I will try to implement this in the branch hydrodynamic_problem.

[sebglane]

The DataPostprocessor framework is implemented in data_postprocessor see PR #125.

[sebglane]

First step towards serialization were implemented in PR #153. Serialization of a problem is still missing.