diff --git a/OpenMP/reader.cpp b/OpenMP/reader.cpp
index 8c02e0d..75b19e8 100644
--- a/OpenMP/reader.cpp
+++ b/OpenMP/reader.cpp
@@ -1,68 +1,68 @@
 //
 // Created by Arnaud Pannatier on 06.05.18.
 //
 
 #include "reader.h"
 #include <fstream>
 #include <iostream>
-
+#include <limits>
 
 Grid Reader::readGridFromFile (std::string filename,std::size_t nx, std::size_t ny) {
     Grid ret = Grid(nx,ny);
     //std::cout << filename << std::endl;
 
     std::ifstream file (filename, std::ios::in | std::ios::binary);
 
 
     if (file.is_open())
     {
         char * memblock;
         file.ignore( std::numeric_limits<std::streamsize>::max() );
         std::streamsize size = file.gcount();
         file.clear();
         //std::cout << size << " --  size " << std::endl;
         memblock = new char[size];
         file.seekg (0, std::ios::beg);
         file.read (memblock, size);
         file.close();
 
         //std::cout << "the entire file content is in memory" << std::endl;
 
         double* double_values = reinterpret_cast<double*>(memblock);
         for(std::size_t x(0); x<nx;x++) {
             for (std::size_t y (0); y < ny; y++) {
                 ret (x, y) = double_values[y * nx + x];
             }
         }
         delete memblock;
 
     }else{
         std::cout<< "File is not open ! " << std::endl;
     }
 
 
     return ret;
 }
 
 void Reader::writeGridInFile (Grid& g,std::string filename, std::size_t nx, std::size_t ny) {
     std::cout << filename << std::endl;
     double* double_values;
     double_values= new double[nx*ny];
     for(std::size_t x(0); x<nx;x++) {
         for (std::size_t y (0); y < ny; y++) {
             double_values[x * nx + y] = g(y,x);
         }
     }
 
     char* memblock = reinterpret_cast<char*>(double_values);
 
     std::ofstream file(filename, std::ios::out | std::ios::binary);
 
     file.write (memblock, sizeof(memblock)*nx*ny);
     std::cout << "Grid Saved ! " << std::endl;
 
 
     delete double_values;
 
 
 }
diff --git a/Sequential/CMakeLists.txt b/Sequential/CMakeLists.txt
index ba29886..11761a1 100644
--- a/Sequential/CMakeLists.txt
+++ b/Sequential/CMakeLists.txt
@@ -1,9 +1,9 @@
-cmake_minimum_required(VERSION 3.9)
+cmake_minimum_required(VERSION 2.8)
 project(phpctsunamiproject)
 
 set(CMAKE_CXX_STANDARD 11)
 
-set(CMAKE_CXX_FLAGS "-O3 -ftree-vectorize")
+set(CMAKE_CXX_FLAGS "-std=c++11 -O3 -ftree-vectorize")
 
 add_executable(Test Test.cpp grid.cpp grid.h)
-add_executable(phpctsunamiproject main.cpp grid.cpp grid.h double_buffer.cpp double_buffer.h simulation.cpp simulation.h reader.cpp reader.h)
\ No newline at end of file
+add_executable(phpctsunamiproject main.cpp grid.cpp grid.h double_buffer.cpp double_buffer.h simulation.cpp simulation.h reader.cpp reader.h)
diff --git a/Sequential/simulation.cpp b/Sequential/simulation.cpp
index ffbc1cd..fa1991a 100644
--- a/Sequential/simulation.cpp
+++ b/Sequential/simulation.cpp
@@ -1,194 +1,196 @@
 //
 // Created by Arnaud Pannatier on 06.05.18.
 // Based on the code of :
 // - Nicolas Richart <nicolas.richart@epfl.ch>
 // - Vincent Keller <vincent.keller@epfl.ch>
 // - Vittoria Rezzonico <vittoria.rezzonico@epfl.ch>
 // See the files AUTHORS and COPYRIGHT for the concerning information
 //
 
 /* -------------------------------------------------------------------------- */
 #include "simulation.h"
 #include "reader.h"
 /* -------------------------------------------------------------------------- */
 #include <math.h>
 #include <sstream>
+#include <chrono>
+#include <limits>
 
 Simulation::Simulation (std::size_t NX_, double G_, int SIZE_, double TEND_, double DX_, std::string dir_)
         :NX(NX_), NY(NX_),dir(dir_), G(G_),TEND(TEND_),DX(DX_),dt(0),T(0),nt(0),SIZE(SIZE_), H(DoubleBuffer(NX,NX)), HU(DoubleBuffer(NX,NX)), HV(DoubleBuffer(NX,NX)), Zdx(Grid(NX,NX)), Zdy(Grid(NX,NX)){};
 
 
 void Simulation::readInitialConditionsFromFile () {
 
     std::stringstream filename, filenameH, filenameHU,filenameHV, filenameZdx, filenameZdy;
     filename << dir << "Data_nx" << NX << "_" << SIZE << "km_T" <<"0.2";
 
     filenameH   << filename.str() <<  "_h.bin";
     filenameHU  << filename.str() <<  "_hu.bin";
     filenameHV  << filename.str() <<  "_hv.bin";
     filenameZdx << filename.str() <<  "_Zdx.bin";
     filenameZdy << filename.str() <<  "_Zdy.bin";
 
     // Load initial condition from data files
     H.current () = Reader::readGridFromFile(filenameH.str(), NX,NX);
     HU.current() = Reader::readGridFromFile(filenameHU.str(), NX,NX);
     HV.current() = Reader::readGridFromFile(filenameHV.str(), NX,NX);
 
     // Load topography slopes from data files
     Zdx = Reader::readGridFromFile(filenameZdx.str(), NX,NX);
     Zdy = Reader::readGridFromFile(filenameZdy.str(), NX,NX);
 
     //std::cout << "ZDX (486,486) " << Zdx(486,486) << std::endl;
     //std::cout << "ZDy (486,486) " << Zdy(486,486) << std::endl;
 
 
     // Allocate memory for computing
     H.old () = Grid(NX,NX);
     HU.old() = Grid(NX,NX);
     HV.old() = Grid(NX,NX);
     
     std::cout << "Data Loaded - Start of Simulation " << std::endl;
 
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<double, int> Simulation::compute() {
     int s = 0;
     double totalTime = 0;
     auto begin = std::chrono::high_resolution_clock::now ();
     readInitialConditionsFromFile();
 
     while(T < TEND){
         s++;
         auto start = std::chrono::high_resolution_clock::now ();
         compute_mu_and_set_dt ();
 
         compute_step();
 
         T = T + dt;
         nt = nt + 1;
 
         auto end = std::chrono::high_resolution_clock::now();
         auto duration = end-start;
         auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
 
         std::cout  << "\r" << " dt : " << dt << " Computing T: " << T << ". " << (100*T/TEND) <<"%" << " --------- Time for a step : " << ms << "                                                     " <<  std::flush;
 
     }
     writeResultsToFile ();
 
     auto end = std::chrono::high_resolution_clock::now();
     auto duration = end-begin;
     totalTime = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
 
     return std::make_tuple(totalTime, s);
 }
 
 
 
 
 /* -------------------------------------------------------------------------- */
 
 void Simulation::compute_mu_and_set_dt () {
 
     double Max = 0.0;
     double Current;
     Grid& cH = H.current();
     Grid& cHU = HU.current();
     Grid& cHV = HV.current();
     
     for(std::size_t i(0); i<m();i++){
         for(std::size_t j(0); j<n(); j++){
             Current = sqrt( +pow(std::max( abs(cHU(i,j)/cH(i,j) - sqrt(cH(i,j)*G)) ,
                                            abs(cHU(i,j)/cH(i,j) + sqrt(cH(i,j)*G)) ) ,2)
                             +pow(std::max( abs(cHV(i,j)/cH(i,j) - sqrt(cH(i,j)*G)) ,
                                            abs(cHV(i,j)/cH(i,j) + sqrt(cH(i,j)*G)) ),2));
             if(Current > Max){
                 Max = Current;
             }
             //if(i == 186 && j == 186){
             //    std::cout << Current << std::endl;
 
             //}
         }
     }
 
     dt = DX/(sqrt(2)*Max);
     //std::cout << "DT : " <<  dt << " --------------------------" << H.current()(486,486) << std::endl;
     if(T+dt > TEND){
         dt = TEND-T;
     }
 }
 
 void Simulation::compute_step () {
     H.swap();
     HU.swap();
     HV.swap();
 
     H.old().applyBoundaryConditions();
     HU.old().applyBoundaryConditions();
     HV.old().applyBoundaryConditions();
 
     Grid& oH = H.old();
     Grid& oHU = HU.old();
     Grid& oHV = HV.old();
     Grid& cH = H.current();
     
     double C = 0.5*dt/DX;
     //std::cout << C << "      " << G << std::endl;
     for(std::size_t i(1);i<m()-1;i++){
         for(std::size_t j(1);j<n()-1;j++) {
 
             /*if(i == 486 && j == 486){
                 std::cout << oH(i,j) << " ------------- " << oHU(i,j) <<  " ----------------------- " << oHV(i,j) << std::endl;
             }*/
 
             H.current()(i,j)    = + 0.25 * ( + oH ( i , j-1 ) + oH ( i , j+1 ) + oH ( i-1 , j ) + oH ( i+1 , j))
                                   + C    * ( + oHU( i , j-1 ) - oHU( i , j+1 )
                                              + oHV( i-1 , j ) - oHV( i+1 , j ));
 
 
             HU.current()(i,j)   = + 0.25 * ( + oHU( i , j-1 ) + oHU( i , j+1 ) + oHU( i-1 , j ) + oHU( i+1 , j )) - dt * G * cH( i , j ) * Zdx( i , j )
                                   + C    * ( + pow( oHU( i , j-1 ) ,2) / oH( i , j-1 ) + 0.5 * G * pow( oH( i , j-1 ) ,2)
                                              - pow( oHU( i , j+1 ) ,2) / oH( i , j+1 ) - 0.5 * G * pow( oH( i , j+1 ) ,2) )
                                   + C    * ( + oHU( i-1 , j ) * oHV( i-1 , j ) / oH( i-1 , j )
                                              - oHU( i+1 , j ) * oHV( i+1 , j ) / oH( i+1 , j ) );
             /*if(i == 486 && j == 486){
 
             std::cout << "HU CONTRIB : ----------------------------- "
                       << + 0.25 * ( + oHU( i , j-1 ) + oHU( i , j+1 ) + oHU( i-1 , j ) + oHU( i+1 , j ))
                       << "------------------------------- "
                       << - dt * G * cH( i , j ) * Zdx( i , j )
                       << "------------------------------- "
                       <<+ C    * ( + pow( oHU( i , j-1 ) ,2) / oH( i , j-1 ) + 0.5 * G * pow( oH( i , j-1 ) ,2) - pow( oHU( i , j+1 ) ,2) / oH( i , j+1 ) - 0.5 * G * pow( oH( i , j+1 ) ,2) )
                       << "------------------------------- "
                       << + C    * ( + oHU( i-1 , j ) * oHV( i-1 , j ) / oH( i-1 , j ) - oHU( i+1 , j ) * oHV( i+1 , j ) / oH( i+1 , j ) ) << std::endl;
 
 
 
             std::cout << dt << "  ----------------------------- " << G << "  ----------------------------- " << cH( i , j ) << "  ----------------------------- " << Zdx( i , j ) << std::endl;
 
             }*/
             HV.current ()(i,j)  = + 0.25 * ( + oHV( i , j-1 ) + oHV( i , j+1 ) + oHV( i-1 , j ) + oHV( i+1 , j )) - dt * G * cH( i , j ) * Zdy( i , j )
                                   + C    * ( + pow( oHV( i-1 , j ),2) / oH( i-1 , j ) + 0.5 * G * pow( oH( i-1 , j ),2)
                                              - pow( oHV( i+1 , j ),2) / oH( i+1 , j ) - 0.5 * G * pow( oH( i+1 , j ),2) )
                                   + C    * ( + oHU( i , j-1 ) * oHV( i , j-1 ) / oH( i , j-1 )
                                              - oHU( i , j+1 ) * oHV( i , j+1 ) / oH( i , j+1 ) );
 
         }
     }
 
     H.current ().imposeTolerances (0.0, 1e-5, H.current());
     HU.current ().imposeTolerances (1e-4, 0.0, H.current());
     HV.current().imposeTolerances (1e-4, 0.0, H.current());
 
 }
 
 void Simulation::writeResultsToFile () {
     std::stringstream file;
     file << dir << "Solution_nx" << NX << "_" << SIZE << "km_T"<<TEND<<"_h.bin";
 
 
 
     Reader::writeGridInFile (H.current (), file.str(), NX,NX);
 }