diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8307391..f09735e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,196 +1,197 @@
 # =============================================================================
 # file   CMakeLists.txt
 #
 # @author Till Junge <till.junge@epfl.ch>
 #
 # @date   08 Jan 2018
 #
 # @brief  Main configuration file
 #
 # @section LICENSE
 #
 # Copyright © 2018 Till Junge
 #
 # µSpectre is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License as
 # published by the Free Software Foundation, either version 3, or (at
 # your option) any later version.
 #
 # µSpectre 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
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with GNU Emacs; see the file COPYING. If not, write to the
 # Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 # =============================================================================
 
 cmake_minimum_required(VERSION 3.5.0)
 project(µSpectre)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(BUILD_SHARED_LIBS ON)
 
 add_compile_options(-Wall -Wextra -Weffc++)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
 set(MAKE_DOC_TARGET "OFF" CACHE BOOL "If on, a target dev_doc (which builds the documentation) is added")
 set(MAKE_TESTS "ON" CACHE BOOL "If on, several ctest targets will be built automatically")
 set(MAKE_EXAMPLES "ON" CACHE BOOL "If on, the executables in the bin folder will be compiled")
 set(MAKE_BENCHMARKS "ON" CACHE BOOL "If on, the benchmarks will be compiled")
 set(MPI_PARALLEL "OFF" CACHE BOOL "If on, MPI-parallel solvers become available")
 
 if(${MAKE_TESTS})
   enable_testing()
   find_package(Boost COMPONENTS unit_test_framework REQUIRED)
 endif(${MAKE_TESTS})
 
 if(${MPI_PARALLEL})
   add_definitions(-DWITH_MPI)
   find_package(MPI)
   if (NOT ${MPI_FOUND})
     message(SEND_ERROR "You chose MPI but CMake cannot find the MPI package")
   endif(NOT ${MPI_FOUND})
 endif(${MPI_PARALLEL})
 
 include(muspectreTools)
 
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
   # using Clang
   add_compile_options(-Wno-missing-braces)
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # using GCC
   add_compile_options(-Wno-non-virtual-dtor)
   string( TOLOWER "${CMAKE_BUILD_TYPE}" build_type )
   if ("release" STREQUAL "${build_type}" )
     add_compile_options(-march=native)
   endif()
   if ("debug" STREQUAL "${build_type}" )
     add_compile_options(-O0)
   endif()
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
   # using Intel C++
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
   # using Visual Studio C++
 endif()
 
 # Do not trust old gcc. the std::optional has memory bugs
 if(${CMAKE_COMPILER_IS_GNUCC})
   if(${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 6.0.0)
     add_definitions(-DNO_EXPERIMENTAL)
   endif()
 endif()
 
 add_external_package(Eigen3 VERSION 3.3.0 CONFIG)
 
 add_external_package(pybind11 VERSION 2.2 CONFIG)
 
 include_directories(
   ${CMAKE_SOURCE_DIR}/src
   ${CMAKE_SOURCE_DIR}
   )
 
 if(APPLE)
   include_directories(${CMAKE_INSTALL_PREFIX}/include ${Boost_INCLUDE_DIRS})
 endif()
 
 #build tests (these are before we add -Werror to the compile options)
 if (${MAKE_TESTS})
   ##############################################################################
   # build tests
   file( GLOB TEST_SRCS "${CMAKE_SOURCE_DIR}/tests/test_*.cc")
 
   add_executable(main_test_suite tests/main_test_suite.cc ${TEST_SRCS})
   target_link_libraries(main_test_suite ${Boost_LIBRARIES} muSpectre)
   add_test(main_test_suite main_test_suite --report_level=detailed --build_info=TRUE)
 
   ##############################################################################
   # copy python test
   file( GLOB PY_TEST_SRCS "${CMAKE_SOURCE_DIR}/tests/python_*.py")
 
   foreach(pytest ${PY_TEST_SRCS})
     get_filename_component(pytest_name ${pytest} NAME)
     configure_file(
       ${pytest}
       "${CMAKE_BINARY_DIR}/${pytest_name}"
       COPYONLY)
   endforeach(pytest ${PY_TEST_SRCS})
   add_test(python_binding_test python_binding_tests.py)
 
   if(${MPI_PARALLEL})
     ############################################################################
     # add MPI tests
     file( GLOB TEST_SRCS "${CMAKE_SOURCE_DIR}/tests/mpi_test_*.cc")
 
     add_executable(mpi_main_test_suite tests/mpi_main_test_suite.cc ${TEST_SRCS})
     target_link_libraries(mpi_main_test_suite ${Boost_LIBRARIES} muSpectre)
     add_test(mpi_main_test_suite1 ${MPIEXEC_EXECUTABLE} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} 1 mpi_main_test_suite --report_level=detailed --build_info=TRUE)
     add_test(mpi_main_test_suite2 ${MPIEXEC_EXECUTABLE} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} 2 mpi_main_test_suite --report_level=detailed --build_info=TRUE)
   endif(${MPI_PARALLEL})
 endif(${MAKE_TESTS})
 
 ################################################################################
 # compile the library
 add_compile_options( -Werror)
 add_subdirectory(
   ${CMAKE_SOURCE_DIR}/src/
   )
 add_subdirectory(
   ${CMAKE_SOURCE_DIR}/language_bindings/
   )
 
 if (${MAKE_DOC_TARGET}) 
   add_subdirectory(
     ${CMAKE_SOURCE_DIR}/doc/
     )
 endif()
 
 ################################################################################
 if (${MAKE_EXAMPLES})
   #compile executables
 
   set(binaries
     ${CMAKE_SOURCE_DIR}/bin/demonstrator1.cc
     ${CMAKE_SOURCE_DIR}/bin/demonstrator2.cc
     ${CMAKE_SOURCE_DIR}/bin/hyper-elasticity.cc
+    ${CMAKE_SOURCE_DIR}/bin/test_plain_mat4.cc
     ${CMAKE_SOURCE_DIR}/bin/small_case.cc)
 
   if (${MPI_PARALLEL})
     set (binaries
       ${binaries}
       ${CMAKE_SOURCE_DIR}/bin/demonstrator_mpi.cc
       )
   endif (${MPI_PARALLEL})
 
   foreach(binaryfile ${binaries})
     get_filename_component(binaryname  ${binaryfile} NAME_WE)
     add_executable(${binaryname} ${binaryfile})
     target_link_libraries(${binaryname} ${Boost_LIBRARIES} muSpectre)
   endforeach(binaryfile ${binaries})
 
   #or copy them
   file (GLOB pybins "${CMAKE_SOURCE_DIR}/bin/*.py")
   foreach(pybin ${pybins})
 
     get_filename_component(binaryname  ${pybin} NAME_WE)
     configure_file(
       ${pybin}
       "${CMAKE_BINARY_DIR}/${binaryname}.py"
       COPYONLY)
   endforeach(pybin ${pybins})
 endif (${MAKE_EXAMPLES})
 
 ################################################################################
 # compile benchmarks
 if(${MAKE_BENCHMARKS})
   file(GLOB benchmarks "${CMAKE_SOURCE_DIR}/benchmarks/benchmark*cc")
   foreach(benchmark ${benchmarks})
     get_filename_component(benchmark_name ${benchmark} NAME_WE)
     add_executable(${benchmark_name} ${benchmark})
     target_link_libraries(${benchmark_name} ${BOOST_LIBRARIES} muSpectre)
   endforeach(benchmark ${benchmark})
 endif(${MAKE_BENCHMARKS})
diff --git a/bin/test_plain_mat4.cc b/bin/test_plain_mat4.cc
new file mode 100644
index 0000000..0c61e57
--- /dev/null
+++ b/bin/test_plain_mat4.cc
@@ -0,0 +1,79 @@
+//cpp script of test_plain_mat4.py necessary to better profile the program
+
+#include "cell/cell_factory.hh"
+#include "materials/material_linear_elastic4.hh"
+#include "solver/solvers.hh"
+#include "solver/solver_cg.hh"
+
+#include <iostream>
+//#include <iomanip>
+
+#include <random>
+
+using namespace muSpectre;
+
+
+int main()
+{
+  std::cout << "startig test_plain_mat4\n";
+
+  const Ccoord_t<threeD> resolution{51, 51, 51};
+  const Rcoord_t<threeD> lengths{5.0, 5.0, 5.0};
+  constexpr Formulation formulation{Formulation::finite_strain};
+
+  auto cell{make_cell<threeD, threeD>(resolution, lengths, formulation)};
+
+  //initialize my material
+  using Material_t = MaterialLinearElastic4<threeD, threeD>;
+  auto mat{std::make_unique<Material_t>("material")};
+
+  //introduce random number generators for Young and Poisson
+  //make random numbers as in std::uniform_real_distribution cppreference.com
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  //set a seed for the random number generation to make reproducable results
+  gen.seed(15);
+  // for Young [5,10)
+  std::uniform_real_distribution<> dis_Y(5, 10);
+  //for Poisson [0.1, 0.4)
+  std::uniform_real_distribution<> dis_P(0.1, 0.4);
+
+  //fill the pixels
+  for (const auto && pixel:cell) {
+    mat->add_pixel(pixel, dis_Y(gen), dis_P(gen));
+  }
+
+  cell.add_material(std::move(mat));       //add the material to the cell
+  cell.initialise(FFT_PlanFlags::measure); //fft initialization, make faster fft
+
+  //set the deformation
+  //DelF = np.array([[0, 0.01, 0],
+  //                 [0, 0   , 0],
+  //                 [0, 0   , 0]])
+  Grad_t<threeD> DelF{Grad_t<threeD>::Zero()};
+  DelF(0, 1) = 0.01;
+
+  //set solver constants
+  const Real newton_tol {1e-6}; //tolerance for newton algo
+  const Real cg_tol     {1e-6}; //tolerance for cg algo
+  const Real equil_tol  {1e-6}; //tolerance for equilibrium / tol for div(P) ?
+  const Uint maxiter    {100};  //maximum cg iterations
+  const Uint verbose    {0};    //verbosity of solver
+
+  GradIncrements<threeD> grads{DelF};
+  SolverCG<threeD> cg{cell, cg_tol, maxiter, bool(verbose)};
+  auto newton_result {newton_cg(cell, grads, cg,
+				newton_tol, equil_tol, verbose)[0]};
+
+  //print some messages of the solver
+  /*
+  std::cout << "gradient F:\n" << newton_result.grad << "\n";
+  std::cout << "\n\nstress:\n" << newton_result.stress << "\n";
+  std::cout << "convergence_test: " << newton_result.success << "\n";
+  std::cout << "status: " << newton_result.status << "\n";
+  std::cout << "message: " << newton_result.message << "\n";
+  std::cout << "# iterations: " << newton_result.nb_it << "\n";
+  std::cout << "# cell evaluations: " << newton_result.nb_fev << "\n";
+  */
+  std::cout << "test_plain_mat4 finished correct\n";
+}