The purpose of the library is to provide an environment for h-adaptive finite-volume computations for conservation laws. The main design goal is to allow an easy interchange among various timestepping schemes, numerical fluxes, reconstructions of boundary extrapolated data, error indicators, but still obtain efficient codes.

Features:

• we use a single (possibly non-uniform) grid, e.g. a quad-tree grid (compare AMRCLaw for a completely different approach to h-adaptivity)
• Runge-Kutta timestepping of orders up to 3
• 1d and 2d spatial reconstructions of orders up to 3
• upwind and local Lax-Friedrichs fluxes provided, easy implementation of your favourite ones
• conservation laws provided by giving their flux function (few scalar examples and Euler equations already included)
• the numerical entropy error indicator from Puppo, Semplice - CiCP(2011) is the deafult choice for adaptivity, but also some geometric error indicators (gradient, curvature, ...) are available
• all of the above is selected at compile-time using static polymorphism (Barton-Nackmann trick) for efficiency
• thanks to the underlying Dune libraries, the source code is (largely) independent on the number of spatial dimesions, on the grid-manager chosen and on the choice between serial/parallel. This allows for efficient code development and maintenance.

Current status

I develop this library since 2012 mainly in order to perform the numerical tests for my papers, so it is currently in "alpha" stage.
However, if you find it useful or if you want to send me any patches that correct bugs or implement new features, I am more then happy to include them (with your copyright, of course!)

Licence

The code is released in source form, under the terms of the GPL licence. You may use it, provided that you make freely available any modification that you make to the library.

Download

Please email me (m a t t e o . s e m p l i c e AT unito.it) with your name, institution and inteded use and I will send you a tarball.

Here below is brief instructions on how to install and use the library.

Intallation and basic usage

dune-fv is a "dune module", so you need to install the Dune libraries first. Please refer to the official web page (https://www.dune-project.org/) and to their very useful mailing lists for help.

This version of dune-fv is tested with version 2.3 of the core Dune modules, so please do not install the latest version: I currently have no plans to update this dependency until dune 3.0 is out.

• So, first install the DUNE library: it is enough to get the dune-common, dune-geometry and dune-grid modules and optionally (if you want to perform 2D h-adaptive computations) also the dune-alugrid module.
• If you want to test the installation so far, try out adaptivefinitevolume.cc example from the dune-grid-howto module.
• Finally unpack the archive in the same directory with the other dune modules, configure and compile dune-fv as you did for the official dune modules.
• Running the freshly compiled dune_fv in the src/ directory will perform your first computation (at second order), leaving the output in the src/output/ directory, if it exists. For more control, you have 3 command line parameters:
  ./dune_fv N L T
    where N=number of coarse cells
         L number of levels
         T threshold for refinement
  The output is in ASCII format and has one cell per row with the following data: center, size, u, numer. entropy
• If you want to solve another conservation law, you currently need to change one line in the dune_fv.cc source code: search for the typedef of Claw close to line 40 (look into dune/fv/claw for the definition of the conservation laws and of the initial data for the tests). In a similar fashion you can also change the error indicator and other finer details... You may want to take inspiration from a patch in my set.
  The output format for systems is similar to the scalar case, but it has more columns.
• Changing the order of the scheme is done at compilattion time, as
  make CPPFLAGS='-w -D FV_REC=r -D FV_RK=p' dune_fv
  replacing p with the desired Runge-Kutta order (1,2, or 3) and r with the desired reconstruction accuracy (1,2, or 3).
• for 2d computations, compile with the command
  GRIDTYPE=ALUGRID_CUBE GRIDDIM=2 make CPPFLAGS='-w -D FV_RK=p -D FV_REC=r dune_fv
  The output format is similar to the 1D case, but it has the x and y coordinate of the cell center at the beginning.
  Some utilities to visualize the output data in Octave/Matlab or to convert it  to vtk format are in the "src/octave" directory.
• A set of patches to reproduce the computations of
  Semplice, Coco, Russo - Adaptive Mesh Refinement for Hyperbolic Systems Based on Third-Order Compact WENO Reconstruction - J Sci Comput (2016) 66:692-724 - DOI 10.1007/s10915-015-0038-z is here.
• In order to add new features (e.g. conservation laws, numerical fluxes, error indicators, timestepping schemes, spatial reconstructions, etc), you may want to change some headers or add new ones in dune/fv/claw, dune/fv/flux, dune/fv/adapt, dune/fv/erk, dune/fv/rec, etc. Have a look at the existing ones... If you do so, and you send me a patch, I'll include it in future releases.
• If you find bugs or have suggestions for improvement, email me at m a t t e o . s e m p l i c e AT u n i t o . i t If you fine the library useful in your work, please cite my paper...