From Carat++ Public Wiki
Jump to: navigation, search

This page shows how Carat++ can be compiled under a Linux environment. The guide was tested with the following software versions:

  • Ubuntu 16.04 LTS
  • gcc 5.4.0
  • git 2.7.4
  • CMake 3.5.1
  • Boost 1.63.0
  • MKL (Intel composer_xe_2013_sp1)


Linux Version

In this installation guide Ubuntu 16.04 LTS is used.

Carat++ installation was tested also under the following Linux distributions:

  1. Ubuntu 16.04 LTS
  2. Ubunut 14.04 LTS
  3. TODO please add more if you tested it there


The compiler used in this guide is gcc 5.4.0.


Git is used as version control system. It is needed to download the Carat++ source code. Check which version is installed:

git --version

If it is not installed yet, install the latest version:

sudo apt-get install git

Get the source code

To get the Carat++ source code navigate to the directory where you want to store the code, e.g.:


Download the code with git. You need to log in wit your LDAP login:

git clone [USERNAME]@

Create directory for build and libraries

Navigate to the carat root directory, previously downloaded:

mkdir build

Create a directory "build" and a directory "libs":

mkdir libs


Install the latest CMake version

sudo apt-get install cmake

It is recommended to use a tool (in this guide ccmake is used) to set all the compiler flags defined in the CMakeLists.txt:

sudo apt-get install ccmake


Get the latest boost library from Download and unpack it. Copy the unpacked folder with the version number into the "carat/libs" directory.


Intel MKL is a equation solving library, that is strongly recommended to use.

This guide shows a simple Installation without any administrator rights. (Advanced: To use all the features of the intel suite please refer to

  1. Copy the "license.lic" from smb://dc01/f_users/TEMP/software/intel_suite into ~/software/intel/ into into e.g. ~/software/intel/.
  2. Copy the Intel Composer package "l_ccompxe_2013_sp1.2.144.tgz" from smb://dc01/f_users/TEMP/software/intel_suite/Intel_Comp14SP1 into e.g. ~/software/intel/.
  3. Unpack it and execute the "".
  4. Select "Install as current user"
  5. Select "Chose alternative activation"
  6. Select "Use a license file"
  7. Browse to "~/software/intel/license.lic"
  8. Costumize installation
  9. Destination Folder: Browse to "~/software/intel/2013/
  10. Ignore warnings about missing Java and 32bit. To use MKL solver this is not needed.
  11. After installation you can delete "l_ccompxe_2013_sp1.2.144.tgz" and l_ccompxe_2013_sp1.2.144

Compile Carat

User Settings

First of all it is necessary to set some paths depending on where you stored the carat source and libs.

Navigate to the Carat++ source directory and make a copy of the "cmake_personal_input.template" to "cmake_personal_input.dat".

cp cmake_personal_input.template cmake_personal_input.dat

In this file you find the following part with commented lines where you have to set your user defined paths:

# set directories paths


#set(CARAT_ROOT "C:/carat")
#set(LIB_BOOST_INCLUDE_DIR "C:/carat/libs/boost_1_55_0")
#set(LIB_BOOST_DIR "C:/carat/libs/boost_1_55_0/boost")
#set(LIB_MKL_DIR "C:/Program Files (x86)/Intel/Composer XE 2011 SP1/mkl")

With the paths used in this installation guide the block should look like (don't forget to remove the #):

# set directories paths


set(CARAT_ROOT "~/software/carat")
set(LIB_BOOST_INCLUDE_DIR "~/software/carat/libs/boost_1_63_0")
set(LIB_BOOST_DIR "~/software/carat/libs/boost_1_63_0/boost")
set(LIB_MKL_DIR "~/software/intel/xe_2013/composer_xe_2013_sp1/mkl")

Set up the project

Navigate to the "build" directory. This is important so that all files are created here:


Use ccmake to set up the project:

ccmake ../src/

Press "c" to configure the project. And set the follwing settings for a very basic installation:

 BUILD_EXECUTABLE                 ON                                                                                                                                                                       
 BUILD_NX_PLUG_IN                 OFF                                                                                                                                                                      
 BUILD_RHINO_PLUG_IN_SDK4         OFF                                                                                                                                                                      
 BUILD_RHINO_PLUG_IN_SDK5         OFF                                                                                                                                                                      
 BUILD_SHARED_LIB                 OFF                                                                                                                                                                      
 BUILD_STATIC_LIB                 OFF                                                                                                                                                                      
 CFD_OPT                          OFF                                                                                                                                                                      
 CMAKE_BUILD_TYPE                 Release                                                                                                                                                                  
 CMAKE_INSTALL_PREFIX             /usr/local                                                                                                                                                               
 ENABLE_CHOLMOD                   OFF                                                                                                                                                                      
 ENABLE_PREC_SOLVER_LIB           OFF                                                                                                                                                                      
 EXTENSIVE_BENCHMARKS             OFF                                                                                                                                                                      
 MODULE_DESIGN                    ON                                                                                                                                                                       
 MODULE_FORM_AND_CUT              ON                                                                                                                                                                       
 MODULE_GUI                       OFF                                                                                                                                                                      
 MODULE_OPTIMIZATION              ON                                                                                                                                                                       
 MODULE_REPORT                    ON                                                                                                                                                                       
 USE_32bit                        OFF                                                                                                                                                                      
 USE_BOOST_LOGGING                OFF                                                                                                                                                                      
 USE_COSIMULATION                 OFF                                                                                                                                                                      
 USE_FLANN_64BIT                  OFF                                                                                                                                                                      
 USE_INTEL_COMP                   OFF                                                                                                                                                                      
 USE_MKL                          ON                                                                                                                                                                      
 USE_MPP                          OFF                                                                                                                                                                      
 USE_OPENCASCADE                  OFF                                                                                                                                                                      
 USE_OPENMP                       OFF                                                                                                                                                                      
 USE_TRILINOS                     OFF  

Press "g" to generate.


Still in the "build" directory:

make -j 8

Now you have a compiled version of Carat++ in your build directory. In Run Carat it is explained how to run Carat++.


After each build or at least before a git commit the benchmarks have to be tested. In the "build" directory type:

make test

Whos here now:   Members 0   Guests 0   Bots & Crawlers 1
Personal tools
Content for Developers