Installation packages

We currently provide installation packages for the openCARP simulator only. You can find them on our release page. Please install carputils and meshalyzer separately.

Linux

For Ubuntu/Debian systems, please download the DEB packages in https://opencarp.org/deb/

We recommand to install the package via apt-get. For example,

cd <path-to-your-downloaded-deb-file>
apt-get update
apt-get install ./opencarp-0.1-Linux.deb

For CentOS/Fedora systems, please download the RPM packages in https://opencarp.org/rpm/

We recommand to install the package via dnf. For example,

cd <path-to-your-downloaded-rpm-file>
dnf install ./opencarp-0.1-Linux.rpm

Mac

We are currently setting up installers for macOS. At the moment, please use Docker or source installation (see below).

Installation of openCARP Docker containers

First, install Docker for your platform.

There are 2 options for the openCARP installation using Docker.

  1. After the Docker installation use docker commands to pull and use the docker images.
  2. Alternatively, install using our script which will take care of all installation steps for you.

Pull the docker image (Option 1)

Pull the latest openCARP docker image:

docker pull docker.opencarp.org/opencarp/opencarp:latest

Pull the latest openCARP developer docker image (only required for openCARP developers):

docker pull docker.opencarp.org/opencarp/opencarp/dev:latest

Run the docker image using the following terminal command:

docker run -it docker.opencarp.org/opencarp/opencarp:latest

You can now use openCARP. Head over to the experiments section to get started.

Install our docker script (Option 2)

Docker provides a variety of commands to utilize docker images:

docker --help

To help you quick start, our script wraps the most commonly used docker commands. Tell the install script where to place the binary files (should be a diretory in your $PATH). Use sudo if admin permission is required to write there:

cd <path-to-your-codebase>/openCARP/docker
./install_script.sh <path-to-your-bin>

For example, to install to /usr/local/bin, run:

sudo ./install_script.sh /usr/local/bin

The script enables you to start with the keyword opencarp-docker followed by the appropriate command.

Make sure the script is installed correctly:

opencarp-docker help

Pull the docker image:

opencarp-docker pull

For usage examples and more information, please refer to our docker/README.

For visualization, please also refer to installation of meshalyzer and locally install meshalyzer because it is not included in the Docker container.

Building openCARP from source

First install the following openCARP prerequisites using your package manager or from their official release.

Prerequisites

  • git
  • binutils
  • C and C++ compilers
  • make
  • CMake
  • PETSc
  • gengetopt
  • zlib-devel

Tips for installing PETSc: If you are not experienced with its various configurations, please refer to the following suggestions. Set --prefix= to the location you would install PETSc. After installation, set the location installed PETSc for the environment variable PETSC_DIR.

./configure \
    --prefix=/opt/petsc \
    --download-mpich \
    --download-fblaslapack \
    --download-metis \
    --download-parmetis \
    --download-hypre \
    --with-debugging=0 \
    COPTFLAGS='-O2' \
    CXXOPTFLAGS='-O2' \
    FOPTFLAGS='-O2'
make all
make install

If you have all the listed dependencies, a quick way to get openCARP up and running is the following:

Clone the repository and enter the codebase folder openCARP

git clone https://git.opencarp.org/openCARP/openCARP.git
cd openCARP

We provide CMake files and Makefiles for building the codebase, choose one fits your workflow.

Building using CMake

Run CMake to create the _build build folder

cmake -S. -B_build

Compile the codebase, and all built executables are located in the _build/bin folder.

cmake --build _build

(Optional) You can also install the executables to the system using

cmake --build _build --target install

Building using the Makefile

The codebase can be compiled using

make setup

This target includes updating the codebase (make update) and code compilation (make all).

Links to all compiled executables are located in the bin folder.

Additional tools

If you would like to install everything locally, please also refer to, install carputils from source, the meshtool main page, and installation of meshalyzer. Download the openCARP examples to the location of your choice using git clone https://git.opencarp.org/openCARP/experiments.git.

Installing carputils from source

Docker

A quick way to get started is pulling the openCARP docker image.

Linux/MacOS

To locally run carputils, first install openCARP, Python3, and pip.

Install Python3 packages using pip.

pip3 install --upgrade pip
pip install scipy matplotlib numpy pandas scipy tables

Clone the carputils repository.

git clone https://git.opencarp.org/openCARP/carputils.git

Add carputils/bin to your PATH, and carputils to your PYTHONPATH For example, if you clone carputils to $HOME/install, add the following lines in your .bashrc:

export PATH=$PATH:$HOME/install/carputils/bin
export PYTHONPATH=$PYTHONPATH:$HOME/install/carputils

Download a settings file for carputils. Specify the proper directories for openCARP-CPU and other openCARP tools if you use them. For example,

CPU: $HOME/install/openCARP/bin

Rename the settings file to settings.yaml and put it in the root directory of the carputils.

Meshalyzer

Meshalyzer is a graphical program for display time dependent data on 3D finite elment meshes. Of course, it can show static data on fewer dimensions as well. It is developed to be compatible with the cardiac simulation environment openCARP.

It uses IGB and its own file formats which are simple and easily converted to/from more popular formats like VTK.

Meshalyzer is regularly used on Linux and Mac machines. It has worked under Windows as well.

Prerequisities

  1. libpng
  2. FLTK 1.3.x. Manually downloaded and installed is better since the prepackaged versions often have issues with fltk-config.
  3. glew.
  4. glut
  5. To make the "windowless" rendering version, OSMesa
  6. To read in VTK/VTU format meshes, install VTK development files

Except for fltk, using your package manager is recommended for installing these packages if possible. On macOS, you could use homebrew.

Compiling

  1. If VTK is installed, edit the make.conf to set the VTK_INC and VTK_DIR variables to point to the directories containing the VTK header files and libraries, respectively. Comment them out otherwise.

  2. Type make

  3. For the windowless version, type make mesalyzer

  4. The compiled executables will be found in the src/ directory.

  5. Copy the binaries to a suitable location

Documentation

To compile the doucmentation a LaTeX package is required. Follow the steps described below to create the Meshalyzer manual.

  1. cd manual
  2. pdflatex manual
  3. pdflatex manual

© Copyright 2020 openCARP project    Supported by DFG    Contact    Imprint and data protection