diff --git a/SConstruct b/SConstruct
index bdb81fe8..266dbcfa 100644
--- a/SConstruct
+++ b/SConstruct
@@ -1,320 +1,321 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # ------------------------------------------------------------------------------
 # Imports
 # ------------------------------------------------------------------------------
 from __future__ import print_function
 import os
 from os.path import join, abspath
 from version import write_info_file
 from detect import FindFFTW, FindBoost, FindThrust, FindCuda, FindExpolit
 # ------------------------------------------------------------------------------
 
 EnsurePythonVersion(2, 7)
 EnsureSConsVersion(2, 4)
 
 
 # ------------------------------------------------------------------------------
 def detect_dependencies(env):
     """Detect all dependencies"""
     FindFFTW(env, ['omp'])
     FindBoost(env, ['boost/preprocessor/seq.hpp'])
     FindExpolit(env)
 
     thrust_var = 'THRUST_ROOT'
 
     # Take cuda version of thrust if available
     if 'CUDA_ROOT' in env['ENV']:
         thrust_var = 'CUDA_ROOT'
 
     FindThrust(env, env['backend'], thrust_var)
 
     # Activate cuda if needed
     if env['backend'] == 'cuda':
         FindCuda(env)
 
 
 # ------------------------------------------------------------------------------
 # Main compilation
 # ------------------------------------------------------------------------------
 
 # Compilation colors
 colors = {
   'cyan': '\033[96m',
   'purple': '\033[95m',
   'blue': '\033[94m',
   'green': '\033[92m',
   'yellow': '\033[93m',
   'red': '\033[91m',
   'end': '\033[0m'
 }
 
 # Inherit all environment variables (for CXX detection, etc.)
 main_env = Environment(ENV=os.environ)
 main_env['COLOR_DICT'] = colors
 
 # Compiler detection
 compiler_default = os.getenv('CXX', 'g++')
 
 # Build variables
 vars = Variables('build-setup.conf')
 vars.AddVariables(
     EnumVariable('build_type', 'Build type', 'release',
                  allowed_values=('release', 'profiling', 'debug'),
                  ignorecase=2),
     EnumVariable('backend', 'Thrust backend', 'omp',
                  allowed_values=('omp',),
                  # allowed_values=('omp', 'cuda'),
                  ignorecase=2),
     EnumVariable('sanitizer', 'Sanitizer type', 'none',
                  allowed_values=('none', 'memory', 'leaks', 'address'),
                  ignorecase=2),
 
     PathVariable('prefix',
                  'Prefix where to install', '/usr/local'),
 
     # Dependencies paths
     PathVariable('FFTW_ROOT',
                  'FFTW custom path', os.getenv('FFTW_ROOT', ''),
                  PathVariable.PathAccept),
     PathVariable('THRUST_ROOT',
                  'Thrust custom path', os.getenv('THRUST_ROOT', ''),
                  PathVariable.PathAccept),
     PathVariable('BOOST_ROOT',
                  'Boost custom path', os.getenv('BOOST_ROOT', ''),
                  PathVariable.PathAccept),
     PathVariable('CUDA_ROOT',
                  'Cuda custom path', os.getenv('CUDA_ROOT', ''),
                  PathVariable.PathAccept),
     # Dependencies provided as submodule get different default
     PathVariable('GTEST_ROOT',
                  'Googletest custom path',
                  os.getenv('GTEST_ROOT', '#third-party/googletest/googletest'),
                  PathVariable.PathAccept),
     PathVariable('PYBIND11_ROOT',
                  'Pybind11 custom path',
                  os.getenv('PYBIND11_ROOT', '#third-party/pybind11/include'),
                  PathVariable.PathAccept),
     PathVariable('EXPOLIT_ROOT',
                  'Expolit custom path',
                  os.getenv('EXPOLIT_ROOT', '#third-party/expolit/include'),
                  PathVariable.PathAccept),
 
     # Executables
     ('CXX', 'Compiler', compiler_default),
     ('py_exec', 'Python executable', 'python3'),
 
     # Cosmetic
     BoolVariable('verbose', 'Activate verbosity', False),
     BoolVariable('color', 'Color the non-verbose compilation output', False),
 
     # Tamaas components
     BoolVariable('build_doc', 'Build documentation', False),
     BoolVariable('build_tests', 'Build test suite', False),
     BoolVariable('build_python', 'Build python wrapper', True),
 
     # Dependencies
     BoolVariable('use_googletest', 'Build tests using GTest', False),
 
     # Strip binary of extra info
     BoolVariable('strip_info', 'Strip binary of added information', False),
 )
 
 # Set variables of environment
 vars.Update(main_env)
 Help(vars.GenerateHelpText(main_env))
 
 # Save all options, not just those that differ from default
 with open('build-setup.conf', 'w') as setup:
     for option in vars.options:
         setup.write("# " + option.help + "\n")
         setup.write("{} = '{}'\n".format(option.key, main_env[option.key]))
 
 main_env['should_configure'] = \
     not main_env.GetOption('clean') and not main_env.GetOption('help')
 
 build_type = main_env['build_type']
 build_dir = 'build-' + main_env['build_type']
 
 if main_env['should_configure']:
     print("Building in " + build_dir)
 
 verbose = main_env['verbose']
 
 # Remove colors if not set
 if not main_env['color']:
     for key in colors:
         colors[key] = ''
 
 if not verbose:
     main_env['SHCXXCOMSTR'] = \
         u'{0}[Compiling ($SHCXX)] {1}$SOURCE'.format(colors['green'],
                                                      colors['end'])
     main_env['SHLINKCOMSTR'] = \
         u'{0}[Linking] {1}$TARGET'.format(colors['purple'],
                                           colors['end'])
 
 # Include paths
 main_env.AppendUnique(CPPPATH=['#/src',
                                '#/src/core',
                                '#/src/bem',
                                '#/src/surface',
                                '#/src/python',
                                '#/src/percolation',
                                '#/src/model',
                                '#/src/model/elasto_plastic',
                                '#/src/solvers',
                                '#/src/gpu',
                                '#/python'])
 
 # Changing the shared object extension
 main_env['SHOBJSUFFIX'] = '.o'
 
 # Back to gcc if cuda is activated
 if main_env['backend'] == "cuda":
     main_env['CXX'] = "g++"
 
 compiler_aliases = {
     "c++": "g++",
     "g++-7": "g++",
     "g++-6": "g++",
     "clang++-6.0": "clang++",
 }
 
 
 def cxx_alias(alias):
     return compiler_aliases.get(alias, alias)
 
 
 # OpenMP flags - compiler dependent
 omp_libs = {
     "g++": ["gomp"],
     "clang++": [],
     "icpc": []
 }
 
 omp_flags = {
     "g++": ["-fopenmp"],
     "clang++": ["-fopenmp=libomp"],
     "icpc": ["-qopenmp"]
 }
 
 cxx = cxx_alias(main_env['CXX'])
 
 omp_lib = omp_libs[cxx]
 omp_flag = omp_flags[cxx]
 
 main_env.AppendUnique(LIBS=omp_lib)
 main_env.AppendUnique(LINKFLAGS=omp_flag)
 
 # Flags and options
 main_env.AppendUnique(CXXFLAGS=['-std=c++14',
                                 '-Wall',
                                 omp_flag])
 
 if main_env['build_python']:
     main_env.AppendUnique(CPPDEFINES=['USE_PYTHON'])
 
 if main_env['strip_info']:
     main_env.AppendUnique(CPPDEFINES=['STRIP_INFO'])
 
 # Adding compile flags defined in evironment
 main_env.AppendUnique(CXXFLAGS=Split(os.getenv('CXXFLAGS', "")))
 
 if build_type == 'debug':
     main_env.AppendUnique(CPPDEFINES=['TAMAAS_DEBUG'])
 
 # Compilation flags
 cxxflags_dict = {
     "debug": Split("-g -O0"),
     "profiling": Split("-g -O3 -fno-omit-frame-pointer"),
     "release": Split("-O3")
 }
 
 # Link flags for shared libs
 shlinkflags_dict = {
     "debug": Split(""),
     "profiling": Split("-g -O3 -fno-omit-frame-pointer"),
     "release": []
 }
 
 if main_env['sanitizer'] != 'none':
     if main_env['backend'] == 'cuda':
         print("Sanitizers with cuda are not yet supported!")
         Exit(1)
     cxxflags_dict[build_type].append(
         '-fsanitize={}'.format(main_env['sanitizer']))
     shlinkflags_dict[build_type].append(
         '-fsanitize={}'.format(main_env['sanitizer']))
 
 main_env.AppendUnique(CXXFLAGS=cxxflags_dict[build_type])
 main_env.AppendUnique(SHLINKFLAGS=shlinkflags_dict[build_type])
 main_env.AppendUnique(LINKFLAGS=shlinkflags_dict[build_type])
 
 main_env['LIBPATH'] = [abspath(join(build_dir, 'src'))]
 main_env['RPATH'] = "$LIBPATH"
 
 if main_env['should_configure']:
     detect_dependencies(main_env)
 
 # Writing information file
 write_info_file("src/tamaas_info.cpp", main_env['build_type'])
 
 
 def write_env_file(target, source, env):
     """Builder to write content to file"""
     env_content = """
     export PYTHONPATH=$PYTHONPATH:{0}/python
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{0}/src
     """
 
     with open(str(target[0]), 'w') as env_file:
         env_file.write(env_content.format(abspath(build_dir)))
 
 
 # Saving the env file
 main_env['gen_print'] = gen_print
 
 env_file_env = main_env.Clone(
     PRINT_CMD_LINE_FUNC=gen_print("Writing", "cyan", main_env)
 )
 
 # Need to have a command and manage tamaas_environement.sh as target because
 # the build directory does not always exist
 env_file_env.Command(join(build_dir, 'tamaas_environement.sh'),
                      None, write_env_file)
 
 
 # Building subdirs
 def subdir(dir):
     return SConscript(join(dir, 'SConscript'),
                       variant_dir=join(build_dir, dir),
                       duplicate=True)
 
 # Building Tamaas library
 Export('main_env')
 subdir('src')
 
 # Building Tamaas extra components
 for dir in ['python', 'tests', 'doc']:
     if main_env['build_{}'.format(dir)] and not main_env.GetOption('help'):
         subdir(dir)
diff --git a/doc/SConscript b/doc/SConscript
index 48ed23cb..0dcb8047 100644
--- a/doc/SConscript
+++ b/doc/SConscript
@@ -1,56 +1,57 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from os.path import join, exists
 from subprocess import call
 Import('main_env')
 
 doxygen_tool = str(Dir('#site_scons/site_tools/doxygen'))
 if not exists(doxygen_tool):
     print("Cloning scons doxygen builder")
 
     # Checking if Mercurial is installed
     env = Environment()
     conf = Configure(env)
     if not conf.CheckProg('hg'):
 	print("Could not find Mercurial needed to clone the doxygen tool")
 	Exit(1)
 
     try:
         call(['hg', 'clone', 'https://bitbucket.org/russel/scons_doxygen', doxygen_tool])
     except:
         print("Error while running Mercurial to clone the doxygen tool")
         Exit(1)
 
 env_doxygen = main_env.Clone(
     tools = ['default', 'doxygen']
 )
 
 src_dir = "#/doc/doxygen"
 file = "Doxyfile"
 build_dir = 'build-' + main_env['build_type'] + '/doc/doxygen'
 Command(join("doxygen", file), join(src_dir, file), [
     Mkdir(build_dir),
     Copy("$TARGET", "$SOURCE")
     ]
 )
 
 env_doxygen.Doxygen("doxygen/Doxyfile")
diff --git a/examples/SConstruct b/examples/SConstruct
index 00a3f4d9..af60e3b7 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -1,30 +1,31 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import os
 
 env = Environment(CC = 'g++',
                   CXXFLAGS = ['-std=c++11', '-g', '-fopenmp', '-O3'],
                   TOOLS = ['default', 'tamaas'],
                   TAMAAS_PATH = '../build-release/',
                   ENV = os.environ)
 
 env.Program('rough_surface.cc')
diff --git a/python/SConscript b/python/SConscript
index 705549f8..d7302971 100644
--- a/python/SConscript
+++ b/python/SConscript
@@ -1,67 +1,68 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from __future__ import print_function
 
 from os.path import abspath
 from SCons.Script import Import, Split, Copy
 
 Import('main_env')
 
 # Pybind11 wrapper
 env_pybind = main_env.Clone(SHLIBPREFIX='')
 env_pybind.Tool(pybind11)
 
 pybind_sources = Split("""
 tamaas_module.cpp
 wrap/core.cpp
 wrap/percolation.cpp
 wrap/surface.cpp
 wrap/model.cpp
 wrap/solvers.cpp
 wrap/test_features.cpp
 """)
 
 if main_env['CXX'] != 'icpc':
     pybind_sources += ["wrap/bem.cpp"]
     env_pybind.AppendUnique(CPPDEFINES="LEGACY_BEM")
 
 # Building the pybind library
 tamaas_wrap = env_pybind.SharedLibrary(
     target='tamaas/_tamaas',
     source=pybind_sources,
     LIBS=['Tamaas'],
     RPATH=[abspath('../src')]
 )
 
 # For some reason link happens too early
 Import('libTamaas')
 env_pybind.Depends(tamaas_wrap, libTamaas)
 
 # Copying the __init__.py file with extra python classes
 copy_env = env_pybind.Clone(
     PRINT_CMD_LINE_FUNC=main_env['gen_print']("Copying", "red", main_env))
 
 copy_env.Command(Dir('tamaas'), Dir('#python/tamaas'), Copy("$TARGET", "$SOURCE"))
 copy_env.Command('setup.py', '#python/setup.py', Copy("$TARGET", "$SOURCE"))
 
 # Cleaning the tamaas python package
 main_env.Execute(Delete('tamaas'))
diff --git a/src/SConscript b/src/SConscript
index 41b88ce2..5b784cf1 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -1,159 +1,160 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import os
 Import('main_env')
 
 
 def prepend(path, list):
     return [os.path.join(path, x) for x in list]
 
 
 env = main_env.Clone()
 
 # Core
 core_list = """
 fft_plan_manager.cpp
 fftransform.cpp
 fftransform_fftw.cpp
 grid.cpp
 grid_hermitian.cpp
 statistics.cpp
 surface.cpp
 tamaas.cpp
 legacy_types.cpp
 loop.cpp
 eigenvalues.cpp
 """.split()
 core_list = prepend('core', core_list)
 
 if not main_env['strip_info']:
     core_list.append('tamaas_info.cpp')
 
 # Lib roughcontact
 generator_list = """
 surface_generator.cpp
 surface_generator_filter.cpp
 surface_generator_filter_fft.cpp
 surface_generator_random_phase.cpp
 isopowerlaw.cpp
 regularized_powerlaw.cpp
 """.split()
 generator_list = prepend('surface', generator_list)
 
 # Lib PERCOLATION
 percolation_list = """
 flood_fill.cpp
 """.split()
 percolation_list = prepend('percolation', percolation_list)
 
 # BEM PERCOLATION
 bem_list = """
 bem_kato.cpp
 bem_polonski.cpp
 bem_gigi.cpp
 bem_gigipol.cpp
 bem_penalty.cpp
 bem_uzawa.cpp
 bem_fft_base.cpp
 bem_functional.cpp
 bem_meta_functional.cpp
 elastic_energy_functional.cpp
 exponential_adhesion_functional.cpp
 squared_exponential_adhesion_functional.cpp
 maugis_adhesion_functional.cpp
 complimentary_term_functional.cpp
 bem_grid.cpp
 bem_grid_polonski.cpp
 bem_grid_kato.cpp
 bem_grid_teboulle.cpp
 bem_grid_condat.cpp
 """.split()
 bem_list = prepend('bem', bem_list)
 
 # Model
 model_list = """
 model.cpp
 model_factory.cpp
 model_type.cpp
 model_template.cpp
 be_engine.cpp
 westergaard.cpp
 elastic_functional.cpp
 meta_functional.cpp
 adhesion_functional.cpp
 volume_potential.cpp
 kelvin.cpp
 mindlin.cpp
 boussinesq.cpp
 
 elasto_plastic/isotropic_hardening.cpp
 elasto_plastic/elasto_plastic_model.cpp
 elasto_plastic/residual.cpp
 
 integration/element.cpp
 """.split()
 model_list = prepend('model', model_list)
 
 # Solvers
 solvers_list = """
 contact_solver.cpp
 polonsky_keer_rey.cpp
 kato.cpp
 beck_teboulle.cpp
 condat.cpp
 polonsky_keer_tan.cpp
 ep_solver.cpp
 epic.cpp
 """.split()
 solvers_list = prepend('solvers', solvers_list)
 
 # GPU API
 gpu_list = """
 fftransform_cufft.cpp
 """.split()
 gpu_list = prepend('gpu', gpu_list)
 
 # Assembling total list
 rough_contact_list = \
   core_list + generator_list + percolation_list + model_list + solvers_list
 
 # For some reason collapse OMP loops don't compile on intel
 if env['CXX'] != 'icpc':
     rough_contact_list += bem_list
 
 # Adding GPU if needed
 if env['backend'] == 'cuda':
     rough_contact_list += gpu_list
 
 # Generating dependency files
 # env.AppendUnique(CXXFLAGS=['-MMD'])
 
 # for file_name in rough_contact_list:
 #     obj = file_name.replace('.cpp', '.os')
 #     dep_file_name = file_name.replace('.cpp', '.d')
 #     env.SideEffect(dep_file_name, obj)
 #     env.ParseDepends(dep_file_name)
 
 # Adding extra warnings for Tamaas base lib
 env.AppendUnique(CXXFLAGS=['-Wextra'])
 libTamaas = env.SharedLibrary('Tamaas', rough_contact_list)
 Export('libTamaas')
diff --git a/tests/SConscript b/tests/SConscript
index b797f557..215f610d 100644
--- a/tests/SConscript
+++ b/tests/SConscript
@@ -1,162 +1,163 @@
-# -*- coding: utf-8 -*-
+# -*- mode:python; coding: utf-8 -*-
+# vim: set ft=python:
 
 # @file
 # @section LICENSE
 #
 # Copyright (©) 2016-19 EPFL (École Polytechnique Fédérale de Lausanne),
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from __future__ import print_function
 from os.path import join, abspath
 
 from SCons.Script import Split, Copy, Dir, Import
 from detect import FindGTest
 
 
 # ------------------------------------------------------------------------------
 def copyComStr(env, main):
     if 'SHCXXCOMSTR' in main:
         env['CXXCOMSTR'] = main['SHCXXCOMSTR']
     if 'SHLINKCOMSTR' in main:
         env['LINKCOMSTR'] = main['SHLINKCOMSTR']
 
 
 # ------------------------------------------------------------------------------
 def make_python_tests(env):
     """Copy python tests to build directory"""
     test_env = env.Clone(
         PRINT_CMD_LINE_FUNC=main_env['gen_print']("Copying", "red", main_env))
 
     test_files = Split("""
     run_tests.sh
     test_hertz.py
     test_westergaard.py
     test_patch_westergaard.py
     test_surface.py
     test_autocorrelation.py
     test_hertz_disp.py
     test_hertz_kato.py
     test_saturated_pressure.py
     test_bem_grid.py
     test_flood_fill.py
     test_integral_operators.py
     test_dumper.py
     test_gtest.py
     test_tangential.py
     test_boussinesq_surface.py
     test_voigt.py
     test_memory.py
     fftfreq.py
     conftest.py
     """)
 
     src_dir = "#/tests"
 
     for file in test_files:
         source = join(src_dir, file)
         test_env.Command(file, source, Copy("$TARGET", "$SOURCE"))
 
     test_env = env.Clone()
     # Helper module for integral operators
     test_env['SHLIBPREFIX'] = ''
     register = test_env.SharedLibrary(target="register_integral_operators",
                                       source=["register_integral_operators.cpp"],
                                       LIBS=['Tamaas'],
                                       RPATH=[abspath('../src')])
     Import('libTamaas')
     test_env.Depends(register, libTamaas)
 
 
 # ------------------------------------------------------------------------------
 def compile_google_test(env, gtest_path):
     gtest_obj = env.Object('gtest.o', [join(gtest_path, "src/gtest-all.cc")])
     return env.StaticLibrary('gtest', gtest_obj)
 
 
 # ------------------------------------------------------------------------------
 def make_google_tests(env):
     gtest_dir = Dir(env['GTEST_ROOT'])
 
     gtest_env = env.Clone(CPPPATH=[gtest_dir],
                           CXXFLAGS=['-pthread', '-isystem',
                                     join(str(gtest_dir), "include")])
 
     colors = env['COLOR_DICT']
 
     if not env['verbose']:
         gtest_env['ARCOMSTR'] = u'{}[Ar]{} $TARGET'.format(colors['purple'],
                                                            colors['end'])
         gtest_env['RANLIBCOMSTR'] = \
             u'{}[Randlib]{} $TARGET'.format(colors['purple'],
                                             colors['end'])
 
     FindGTest(gtest_env)
 
     libgtest = None
     # Hugly hack to detect if we need to compile gtest submodule
     if env['GTEST_ROOT'] == '#third-party/googletest/googletest':
         gtest_path = str(gtest_dir)
         libgtest = compile_google_test(gtest_env, gtest_path)
 
     env.AppendUnique(LIBS=['Tamaas'],
                      CXXFLAGS=gtest_env['CXXFLAGS'])
 
     google_test_files = Split("""
                               test_fft.cpp
                               test_grid.cpp
                               test_loop.cpp
                               test_model.cpp
                               test_static_types.cpp
                               test_integration.cpp
                               """)
 
     gtest_main = env.Object("tamaas_gtest_main.o", 'tamaas_gtest_main.cc')
     gtest_all = env.Program('test_gtest_all', google_test_files + [gtest_main],
                             LIBS=(env['LIBS'] + ['gtest']))
     Import('libTamaas')
     env.Depends(gtest_all, libTamaas)
     env.Depends(gtest_all, libgtest)
 
 
 # ------------------------------------------------------------------------------
 def make_bare_tests(env):
     rough = env.Program("test_rough_surface.cpp")
     Import('libTamaas')
     env.Depends(rough, libTamaas)
 
 
 # ------------------------------------------------------------------------------
 Import('main_env')
 
 # Setup of test environment
 test_env = main_env.Clone()
 test_env.AppendUnique(LIBS=['Tamaas'], LIBPATH=['.'])
 copyComStr(test_env, main_env)
 
 
 # Building tests that do not require any third party
 make_bare_tests(test_env)
 
 if test_env['build_python']:
     test_env.Tool(pybind11)
     test_env.ParseConfig("{}-config --ldflags".format(test_env['py_exec']))
     test_env['CCFLAGS'] = []
 
     make_python_tests(test_env)
 
 # Building google tests
 if test_env['use_googletest']:
     make_google_tests(test_env)