README.md 10 KB
Newer Older
Dion Haefner's avatar
Dion Haefner committed
1 2 3 4 5
# Welcome to DORiE!
(__D__UNE-__O__perated __Ri__chards equation solving __E__nvironment)

[![build status](http://shangrila.iup.uni-heidelberg.de:30000/ci/projects/1/status.png?ref=master)](http://shangrila.iup.uni-heidelberg.de:30000/ci/projects/1?ref=master)

6 7 8 9 10 11 12 13 14
DORiE is a software suite for solving Richard's Equation. The core feature is a C++ PDE-solver powered by [DUNE](https://dune-project.org/). It implements a Discontinous Galerkin (DG) discretization scheme on structured rectangular and unstructured simplex grids in two and three spatial dimensions, and makes use of advanced features like adaptive grid refinement.

The suite encapsulates a documentation and various tools for program setup, program testing, and output analysis, which are mostly written in Python.

DORiE is developed and maintained by the [DORiE Developers](mailto:dorieteam@iup.uni-heidelberg.de) of the [TS-CCEES](http://ts.iup.uni-heidelberg.de/) research group at IUP Heidelberg, in collaboration with [Ole Klein](https://conan.iwr.uni-heidelberg.de/people/oklein/) and the [Scientific Computing Group](https://conan.iwr.uni-heidelberg.de/) of IWR Heidelberg, supervised by [Kurt Roth](http://ts.iup.uni-heidelberg.de/people/prof-dr-kurt-roth/). 


# Installation Instructions

15 16 17 18
DORiE is a [DUNE](https://dune-project.org/) module and requires several other DUNE modules as well as third party software packages. Installation can be handled manually on your local machine, but it's recommended to use the virtualization software [Docker](https://www.docker.com/) instead.

In any case, DORiE is configured, build, and installed via the [DUNE Buildsystem](https://dune-project.org/doc/installation/), using the `dunecontrol` script to handle DUNE-internal dependencies.

19
## Docker Installation
20 21
Install Docker on your machine. We prepared the [DORiE DUNE Environment Image](https://hub.docker.com/r/dorie/dune-env/) on [Dockerhub](https://hub.docker.com/). It's an image of the Ubuntu OS with all dependencies readily installed. The current version is v2.4 (referencing the DUNE module versions 2.4).
Run a new container from this image by calling
22 23 24

    docker run -i -t dorie/dune-env:2.4 /bin/bash

25
Docker will automatically download the image if you did not already `docker pull` it. Use the `-v` option of the `run` command to mount a local directory into the container:
26 27 28

    -v <hostdir/dorie>:/opt/dune/dorie

29
This way, you can access the content of the (still empty) folder of the virtual machine from your local `<hostdir>/dorie` directory. *Mounting directories is not possible after your container has been started!*
30 31 32 33 34

Next, `git clone` the DORiE repository into the shared folder. Enter the container, and execute

    dunecontrol --only=dorie all

35 36 37
to build DORiE. Lastly, install the DORiE binaries by calling

    dunecontrol --only=dorie make install
38

39
### Update DUNE
40 41 42 43
The DUNE modules in the repository might be outdated. You can update to the newest versions by calling

    dunecontrol update

44
Then compile and install all modules again by executing
45

46
    dunecontrol all && dunecontrol make install
47

Dion Haefner's avatar
Dion Haefner committed
48

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
## Manual Installation
Installing all packages manually can be quite an effort, but useful for developers who want to easily access documentation material and source files of the dependency packages. Whenever possible, dependencies should be installed using a package manager, like [APT](https://wiki.ubuntuusers.de/APT/) on Ubuntu or [Homebrew](http://brew.sh/) on Mac. Manual installation on a Windows environment is strongly discouraged!

### Dependencies
Depending on your system configuration, there will be more packages necessary to install the software on your machine. See the step-by-step manual for further details.

| Software | Version/Branch | Comments |
| ---------| -------------- | -------- |
| CMake | >= 3.0 |
| doxygen |
| GCC | >= 5 |
| git |
| pkg-config |
| HDF5 | | MPI library
| FFTW3 | | MPI library
| METIS |
| ParMETIS |
| Python | 3 |
| Python Pip | 3 |
| OpenMPI | >= 2 |
| SuperLU | >=5 |
| ----- | ----- | ----- |
| Breathe | | Install via `pip` |
| Sphinx | | Install via `pip` |
| VirtualEnv | | Install via `pip` |
| ----- | ----- | ----- |
[UG](https://gitlab.dune-project.org/ug/ug) | 3.12.1 | Follow the [IWR Installation Instructions](http://www.iwr.uni-heidelberg.de/frame/iwrwikiequipment/software/ug)
| [dune-common](https://gitlab.dune-project.org/core/dune-common) | releases/2.4
| [dune-geometry](https://gitlab.dune-project.org/core/dune-geometry) | releases/2.4
| [dune-grid](https://gitlab.dune-project.org/core/dune-grid) | releases/2.4
| [dune-istl](https://gitlab.dune-project.org/core/dune-istl) | releases/2.4
| [dune-localfunctions](https://gitlab.dune-project.org/core/dune-localfunctions) | releases/2.4
| [dune-typetree](https://gitlab.dune-project.org/pdelab/dune-typetree) | releases/2.4
| [dune-pdelab](https://gitlab.dune-project.org/pdelab/dune-pdelab) | releases/2.4
| [dune-python](https://gitlab.dune-project.org/quality/dune-python) | releases/2.4
| [dune-testtools](https://gitlab.dune-project.org/quality/dune-testtools) | releases/2.4

### Ubuntu Manual Installation
The following instructions follow the installation instructions on a 'clean' Ubuntu system and are similarly executed to create the DORiE Docker image from an Ubuntu Docker image.

1. Install the third party software using `apt-get`:
Dion Haefner's avatar
Dion Haefner committed
90
    
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
        apt-get update && apt-get install -y \
        autoconf \
        bison \
        cmake \
        doxygen \
        flex \
        gcc-5 \
        g++-5 \
        gfortran-5 \
        git \
        libatlas-base-dev \
        libfftw3-dev \
        libfftw3-mpi-dev \
        libfreetype6-dev \
        libhdf5-mpi-dev \
        libmetis-dev \
        libopenmpi-dev \
        libpng-dev \
        libscotchparmetis-dev \
        libsuperlu-dev \
        libxft-dev \
        python3-dev \
        python3-pip

2. Install the necessary Python packages using `pip`:
        
        python3 -m pip install virtualenv
        python3 -m pip install sphinx
        python3 -m pip install breathe

3. Clone UG into a suitable folder on your machine and `git checkout` the specified version. Install it by calling

        autoreconf -is
        ./configure --prefix=<dir> --enable-parallel --without-x --enable-dune --enable-system-heap
        make && make install

    Replace `<dir>` with a installation directory of choice.

4. Clone the DUNE modules and DORiE into a suitable folder on your machine. Make sure that you `git checkout` the specified branches. Enter the folder, and call

        ./dune-common/bin/dunecontrol all -DCMAKE_CXX_FLAGS="-O3"
132
        ./dune-common/bin/dunecontrol make install
133 134 135 136 137 138

    If you installed software into paths not appended to your `PATH` variable, you will have to add a custom options file to make sure that CMake finds all packages. See the [DUNE Installation Instructions](https://dune-project.org/doc/installation/) for details. CMake will throw an error if required packages are not found.

## Recommended Third-Party Software

The following software packages are cross-platform, so you should be able to find a release that fits your operating system:
Dion Haefner's avatar
Dion Haefner committed
139 140 141 142 143 144

* [Gmsh](http://gmsh.info/): An open-source CAD that can be used to create the `.msh` files used by DORiE to define triangular meshes.
* [ParaView](http://www.paraview.org/): A powerful post-processing tool for VTK files. Offers both visualization and data analysis tools.
* [Python VTK tools](http://www.vtk.org/Wiki/VTK/Examples/Python): If you want to write your own post-processing in python, you may use these tools which supply readers for binary VTK files.


145
# Usage
Dion Haefner's avatar
Dion Haefner committed
146 147


148
## Documentation
Dion Haefner's avatar
Dion Haefner committed
149

150
The documentation of the current `master` branch can be found [online](http://dorie-docs.gitballoon.com) (password: `richards`).
Dion Haefner's avatar
Dion Haefner committed
151

152
The documentation can be built after DORiE has been properly configured (i.e., by calling `dunecontrol`). Enter the build directory of DORiE (`dorie/build-cmake`) and execute
Dion Haefner's avatar
Dion Haefner committed
153

154
    make doc
Dion Haefner's avatar
Dion Haefner committed
155

156
The documentation files can now be found in the subfolder `dorie/build-cmake/doc`.
Dion Haefner's avatar
Dion Haefner committed
157

158
## Usage
159 160 161 162 163 164 165 166 167 168 169
DORiE installs a binary wrapper to access the functions and executables of DORiE from any location on your device. After a successful installation, you can call the wrapper by simply executing

    dorie <command>

To start your first simulation run, create a new directory and enter it. Place some exemplary configuration files in there by calling

    dorie create

Tweak the paramters to your liking and then call

    dorie run <inifile>
Dion Haefner's avatar
Dion Haefner committed
170

171
to execute the program.
Dion Haefner's avatar
Dion Haefner committed
172

173
List all available commands and find further help by executing
Dion Haefner's avatar
Dion Haefner committed
174

175
    dorie help
Dion Haefner's avatar
Dion Haefner committed
176

177 178
## Troubleshooting
In case you encounter errors or strange behavior, you should first take a look at the [List of Known Bugs](http://shangrila.iup.uni-heidelberg.de:30000/dorie/dorie/issues?assignee_id=&author_id=&label_name=bug&milestone_id=&scope=all&sort=created_desc&state=opened). For problems related to the installation, refer to the sections below.
Dion Haefner's avatar
Dion Haefner committed
179

180
### Debugging
181
DORiE supports debugging builds via CMake. Navigate to the build directory (`dorie/build-cmake`) and execute
182 183 184 185 186 187 188 189 190 191 192

    cmake -D CMAKE_BUILD_TYPE=Debug .. && make all

to reconfigure DORiE into a debugging build. This builds DORiE without optimization and inlcudes debugging flags. After building, a debugger can hook into the executables.

**Notice:** If no `CMAKE_BUILD_TYPE` is specified during re-configuration, the last configuration build type is used. If no CMake files exist, it defaults to `None`. You will find the actual value displayed in the final output of CMake.

To re-create a default build, configure DORiE with the default build type (`None`) by executing

    cmake -D CMAKE_BUILD_TYPE=None .. && make all

Dion Haefner's avatar
Dion Haefner committed
193
### DORiE is running, but I suspect that something is wrong
194
You can execute system tests in order to ensure that DORiE is running correctly and producing the expected results. Navigate to the build directory (`dorie/build-cmake`) end execute
Dion Haefner's avatar
Dion Haefner committed
195

196
    make test
Dion Haefner's avatar
Dion Haefner committed
197 198 199

You will be informed whether each test has been passed or failed, and you may find additional output in the DORiE build directory.

200
### Further Help
Dion Haefner's avatar
Dion Haefner committed
201
Open an issue, or write to the [DORiE developer mailing list](mailto:dorieteam@iup.uni-heidelberg.de).