diff --git a/src/core/tamaas.hh b/src/core/tamaas.hh
index c272afd..a97c5c3 100644
--- a/src/core/tamaas.hh
+++ b/src/core/tamaas.hh
@@ -1,176 +1,167 @@
 /**
  * @mainpage Welcome to Tamaas !
  *
  * @section Introduction
  * Tamaas is a spectral-boundary-element based contact library. It is made with
  * love to be fast and friendly!
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frérot <lucas.frerot@epfl.ch>
  * @author Valentine Rey <valentine.rey@epfl.ch>
  *
  * @section LICENSE
  *
  * Copyright (©)  2016-2017 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Tamaas is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Tamaas 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  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef __TAMAAS_HH__
 #define __TAMAAS_HH__
 /* -------------------------------------------------------------------------- */
 #include <exception>
 #include <string>
 #include <complex>
 #include <iostream>
 #include <map>
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifdef USE_CUDA
 #include "unified_allocator.hh"
 #include <thrust/complex.h>
 #endif
 
 /// Namespace macros
 #define __BEGIN_TAMAAS__ namespace tamaas {
 #define __END_TAMAAS__ }
 
 /// Standard definitions pulled from C++14
 namespace std {
 #if __cplusplus < 201402L
   /// exchange
   template<class T, class U = T>
   T exchange(T& obj, U&& new_value)
   {
     T old_value = move(obj);
     obj = forward<U>(new_value);
     return old_value;
   }
   /// make_unique
   template<typename T, typename... Args>
   unique_ptr<T> make_unique(Args&&... args)
   {
     return unique_ptr<T>(new T(forward<Args>(args)...));
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 __BEGIN_TAMAAS__
 /* -------------------------------------------------------------------------- */
 
 #ifdef USE_CUDA
 #define DEFAULT_ALLOCATOR UnifiedAllocator<T>
 #define CUDA_LAMBDA __device__ __host__
 #else
 #define DEFAULT_ALLOCATOR std::allocator<T>
 #define __global__
 #define __host__
 #define __device__
 #define CUDA_LAMBDA
 #endif
 
 
 /// Common types definitions
 using Real = double;
 using UInt = unsigned int;
 using Int  = int;
 #ifdef USE_CUDA
 template <typename T> using complex = thrust::complex<T>;
 #else
 template <typename T> using complex = std::complex<T>;
 #endif
 using Complex = complex<Real>;
 static constexpr Real zero_threshold = 1e-14;
 
 /* -------------------------------------------------------------------------- */
 /// initialize tamaas (0 threads => let OMP_NUM_THREADS decide)
 void initialize(UInt num_threads = 0);
 /// cleanup tamaas
 void finalize();
 /* -------------------------------------------------------------------------- */
 
-// template <typename T>
-// __device__ __host__ complex<T> conjugate(const complex<T> & z) {
-// #ifdef USE_CUDA
-//   return thrust::conj(z);
-// #else
-//   return std::conj(z);
-// #endif
-// }
-
 #ifdef USE_CUDA
 using ::thrust::conj;
 using ::thrust::sqrt;
 using ::thrust::norm;
 #endif
 using ::std::conj;
 using ::std::sqrt;
 using ::std::norm;
 
 /* -------------------------------------------------------------------------- */
 /// Generic exception class
 class Exception : public std::exception {
 public:
   /// Constructor
   Exception(const std::string & mesg):msg(mesg) {}
 
   virtual const char* what() const noexcept {
     return msg.c_str();
   }
 
   virtual ~Exception() = default;
 
 private:
   std::string msg;
 };
 /* -------------------------------------------------------------------------- */
 /// Enumeration of reduction operations
 enum class operation { plus, times, min, max };
 /* -------------------------------------------------------------------------- */
 __END_TAMAAS__
 /* -------------------------------------------------------------------------- */
 
 #define TAMAAS_EXCEPTION(mesg)	{			\
     std::stringstream sstr;				\
     sstr						\
       <<  __FILE__					\
       << ":" << __LINE__ << ":FATAL: "			\
       << mesg << std::endl;				\
     std::cerr.flush();					\
     throw ::tamaas::Exception(sstr.str());		\
   }
 
 #define SURFACE_FATAL(mesg) TAMAAS_EXCEPTION(mesg)
 
 #if defined(TAMAAS_DEBUG)
 #define TAMAAS_ASSERT(cond, reason) do {			\
     if (!(cond)) {						\
       TAMAAS_EXCEPTION(#cond " assert failed: " << reason);	\
     } } while(0)
 #define TAMAAS_DEBUG_EXCEPTION(reason) TAMAAS_EXCEPTION(reason)
 #else
 #define TAMAAS_ASSERT(cond, reason)
 #define TAMAAS_DEBUG_EXCEPTION(reason)
 #endif
 #define TAMAAS_ACCESSOR(var, type, name) type & get##name() { return var; }	\
   void set##name(const type & new_var) { var = new_var; }
 
 /* -------------------------------------------------------------------------- */
 
 #endif // TAMAAS_HH