diff --git a/CG_Parallel/CG_MPI b/CG_Parallel/CG_MPI
deleted file mode 100755
index 9e97426..0000000
Binary files a/CG_Parallel/CG_MPI and /dev/null differ
diff --git a/CG_Parallel/CG_Parallel.cpp b/CG_Parallel/CG_Parallel.cpp
index 33923fe..805fd7c 100644
--- a/CG_Parallel/CG_Parallel.cpp
+++ b/CG_Parallel/CG_Parallel.cpp
@@ -1,209 +1,210 @@
 //
 // Created by shernand on 29/05/19.
 //
 /**
  * @file CG_Serial.cpp
  * @author Sergio Hernandez
  * This file is part of the Conjugate Gradient Project
  *
  * This class implements the parallel version of the Conjugate Gradient
  *
  */
 #include <ctime>
 #include <mpi/mpi.h>
 #include <cmath>
 #include <iostream>
 #include "CG_Parallel.hpp"
 /**
  * Complete constructor of the CG solver.
  * @param matrixA std::vector<double> NxN symmetric definite positive
  * @param vectorB Nx1 std::vector<double> right side vector
  * @param tol double Tolerance for our stopping criterion
  * @param maxIter int Maximum number of iterations of the stopping criterion
  */
 CG_Parallel::CG_Parallel(std::vector<double> const &matrixA, std::vector<double> const &vectorB, double const &tol,
                      int const &maxIter) {
     setMatrixA(matrixA);
     setVectorB(vectorB);
     setTol(tol);
     setMaxIterations(maxIter);
+    std::vector<double> timings(3,0.0);
 }
 
 /**
  * Computes the CG solver
  * @param x_0 Nx1 std::vecotr<double> the initial guess for the solution
  * @return std::tuple<std::vector<double> x, int n_iterations> The tuple <solution, (Nx1 double) and how many iterations
  * it took.
  */
 std::tuple<std::vector<double>,int> CG_Parallel::computeCG(std::vector<double> &x_0) {
     std::vector<double> b = getVectorB();
     std::vector<double> mA = getMatrixA();
     int max_iter = getMaxIterations();
     double tol = getTol();
     std::vector<double> x_k = x_0;
     std::vector<double> r_k = matrixVector(mA,x_k);
     r_k = vectorScalarMul(r_k,-1.0);
     r_k = vectorVectorSum(b,r_k);
     std::vector<double> d_k = r_k;
     double norm_res = vectorVectorDot(r_k,r_k);
     int k = 0;
     while ((norm_res>tol)&&(k<max_iter)){
         std::vector<double> A_dk = matrixVector(mA,d_k);
         double dk_A_dk = vectorVectorDot(d_k,A_dk);
         double alpha_k = norm_res/dk_A_dk;
 
         x_k = vectorVectorSum(x_k,vectorScalarMul(d_k,alpha_k));
         A_dk = vectorScalarMul(A_dk,-alpha_k);
         r_k= vectorVectorSum(r_k,A_dk);
         double norm_r_k_1 = vectorVectorDot(r_k,r_k);
         double beta_k_1 = norm_r_k_1/norm_res;
         d_k = vectorVectorSum(r_k,vectorScalarMul(d_k,beta_k_1));
         norm_res=norm_r_k_1;
         k+=1;
     }
     return std::make_tuple(x_k,k);
 }
 
 /**
  * The operation scalar*vector
  * @param pVector1 Nx1 std::vector<double>
  * @param pScalar double
  * @return mul_vector Nx1 std::vector<double> mult element wise of the scalar and the vector
  */
 std::vector<double> CG_Parallel::vectorScalarMul(const std::vector<double> &pVector1, const double pScalar) {
     int size,rank;
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     int n = pVector1.size();
     int batchSize = n / size;
     std::vector<double> mul_vector(n,0.0);
     std::vector<double> subVec1(batchSize, 0.0);
     std::vector<double> subMul(batchSize, 0.0);
     double scalar = pScalar;
     MPI_Bcast(&scalar, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     MPI_Scatter(pVector1.data(), batchSize, MPI_DOUBLE, subVec1.data(), batchSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     for(int i=0;i<batchSize;i++){
         subMul[i]= subVec1[i]*scalar;
     }
     //So that everyone gets a copy
     MPI_Allgather(subMul.data(), batchSize, MPI_DOUBLE, mul_vector.data(), batchSize, MPI_DOUBLE, MPI_COMM_WORLD);
     return mul_vector;
 }
 
 /**
  * The operation vector+vector
  * @param pVector1 Nx1 std::vector<double>
  * @param pVector2 Nx1 std::vector<double>
  * @return sum_vector Nx1 std::vector<double> sum element wise of the two vectors
  */
 std::vector<double> CG_Parallel::vectorVectorSum(const std::vector<double> &pVector1, const std::vector<double> pVector2) {
     int size,rank;
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     int n = pVector1.size();
     std::vector<double> sum_vector(n,0.0);
     int batchSize = n / size;
     //Should manage the offset if n is not exactly divisible bz size.
     // if (n % size) {
     //    batchSize++;
     //}
     std::vector<double> subVec1(batchSize, 0.0);
     std::vector<double> subVec2(batchSize, 0.0);
     std::vector<double> subSum(batchSize, 0.0);
     MPI_Scatter(pVector1.data(), batchSize, MPI_DOUBLE, subVec1.data(), batchSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     MPI_Scatter(pVector2.data(), batchSize, MPI_DOUBLE, subVec2.data(), batchSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     for (int i = 0;i<batchSize;i++) {
         subSum[i] = subVec1[i]+subVec2[i];
     }
     //Allgather so everyone has a copy.
     MPI_Allgather(subSum.data(), batchSize, MPI_DOUBLE, sum_vector.data(), batchSize, MPI_DOUBLE, MPI_COMM_WORLD);
     return sum_vector;
 }
 
 /**
  * The operation vector*vector
  * @param pVector1 Nx1 std::vector<double>
  * @param pVector2 Nx1 std::vector<double>
  * @return double the resulting dot product
  */
 double CG_Parallel::vectorVectorDot(const std::vector<double> &pVector1, const std::vector<double> pVector2) {
     int size, rank;
     MPI_Status status;
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     int const batchSize = pVector1.size()/size;
     std::vector<double> subVec1(batchSize, 0.0);
     std::vector<double> subVec2(batchSize, 0.0);
     MPI_Scatter(pVector1.data(), batchSize, MPI_DOUBLE, subVec1.data(), batchSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     MPI_Scatter(pVector2.data(), batchSize, MPI_DOUBLE, subVec2.data(), batchSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     double partial_dot_product = 0.0;
     double total_dot_product = 0.0;
     for (int i=0;i<batchSize;i++) {
         partial_dot_product += subVec1[i] * subVec2[i];
     }
     //We use Allreduce so everyone gets a copy.
     MPI_Allreduce(&partial_dot_product, &total_dot_product, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
     return total_dot_product;
 }
 /**
  * The operation Matrix*Vector. This is the most expensive operation.
  * @param pMatrix NxN matrix std::vector<double>
  * @param pVector Nx1 vector std::vector<double>
  * @return prod_vecotr Nx1 std::vector<double>
  */
 std::vector<double> CG_Parallel::matrixVector(const std::vector<double> &pMatrix, const std::vector<double> pVector) {
     int size, rank;
     MPI_Status status;
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     int n = pVector.size();
     int nRows = n/size;
     std::vector<double> vector =pVector;
     MPI_Bcast(vector.data(), n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     std::vector<double> subMatrix(n*nRows,0.0);
     MPI_Scatter(pMatrix.data(), n*nRows, MPI_DOUBLE, subMatrix.data(), n*nRows, MPI_DOUBLE, 0, MPI_COMM_WORLD);
     std::vector<double> prod_vector(n,0.0);
     std::vector<double> subProd(nRows, 0.0);
     for(int i=0;i<nRows;i++){
         double sum_term = 0.0;
         for(int j=0;j<vector.size();j++){
             sum_term+= subMatrix[j+vector.size()*i]*vector[j];
         }
         subProd[i]=sum_term;
     }
     MPI_Allgather(subProd.data(), nRows, MPI_DOUBLE, prod_vector.data(), nRows, MPI_DOUBLE, MPI_COMM_WORLD);
     return prod_vector;
 }
 
 //-------------------Getters-Setters----------------------
 const std::vector<double> &CG_Parallel::getMatrixA() const {
     return matrixA;
 }
 
 void CG_Parallel::setMatrixA(const std::vector<double> &matrixA) {
     CG_Parallel::matrixA = matrixA;
 }
 
 const std::vector<double> &CG_Parallel::getVectorB() const {
     return vectorB;
 }
 
 void CG_Parallel::setVectorB(const std::vector<double> &vectorB) {
     CG_Parallel::vectorB = vectorB;
 }
 
 double CG_Parallel::getTol() const {
     return tol;
 }
 
 void CG_Parallel::setTol(double tol) {
     CG_Parallel::tol = tol;
 }
 
 int CG_Parallel::getMaxIterations() const {
     return max_iterations;
 }
 
 void CG_Parallel::setMaxIterations(int maxIterations) {
     max_iterations = maxIterations;
 }
diff --git a/CG_Parallel/CMakeLists.txt b/CG_Parallel/CMakeLists.txt
index 2d88509..d6b9797 100644
--- a/CG_Parallel/CMakeLists.txt
+++ b/CG_Parallel/CMakeLists.txt
@@ -1,29 +1,29 @@
 
 cmake_minimum_required(VERSION 3.14)
 project(CG_Parallel)
 
 set(CMAKE_CXX_STANDARD 14)
 set(DOC_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/doc)
 find_package(MPI REQUIRED)
 include_directories(/usr/include/mpi/)
 SET(CMAKE_C_COMPILER mpicc)
 SET(CMAKE_CXX_COMPILER mpicxx)
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no-pie -Wall -pg  -Wextra -pedantic -std=c++11 -O2") #Profiling
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -std=c++14 -O2")
-set(SOURCE_FILES main.cpp  CG_Parallel.cpp CG_Parallel.hpp)
+set(SOURCE_FILES main.cpp  CG_Parallel.cpp CG_Parallel.hpp ConfigFileParser.cpp ConfigFileParser.hpp FileParserException.h FileNotFoundException.h)
 
 add_executable(CG_Parallel ${SOURCE_FILES})
 
 #ConfigFileParser.cpp Writter.cpp
 
 #Copies files for Doxygen and test running
 file(COPY "Doxyfile" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
 file(COPY "atom_icon_192.ico" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
 file(MAKE_DIRECTORY ${DOC_FOLDER})
 find_package(Doxygen)
 add_custom_target(doc
         ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
         COMMENT "Generating API documentation with Doxygen" VERBATIM
         )
 file(COPY ${DOC_FOLDER}      DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/CG_Parallel/ConfigFileParser.cpp b/CG_Parallel/ConfigFileParser.cpp
index fa753cf..992184a 100644
--- a/CG_Parallel/ConfigFileParser.cpp
+++ b/CG_Parallel/ConfigFileParser.cpp
@@ -1,92 +1,86 @@
 /** @file ConfigFileParser.cpp
  *  @author Sergio Hernandez
  *
  * This file is part of the Conjugate Gradient Project
  *
  *
  * This class performs the parsing of a standard configuration file.
  *
  */
 #include "ConfigFileParser.hpp"
 
 ConfigFileParser::ConfigFileParser() {
         defaultKeys.push_back("type_input");
-        defaultKeys.push_back("newton_g");
-        defaultKeys.push_back("timestep");
-        defaultKeys.push_back("box_size");
-        defaultKeys.push_back("softening");
-        defaultKeys.push_back("tree_thres");
-        defaultKeys.push_back("display_f");
-        defaultKeys.push_back("n_particles");
-        defaultKeys.push_back("scale_radius");
-        defaultKeys.push_back("n_time_steps");
+        defaultKeys.push_back("N");
+        defaultKeys.push_back("tol");
+        defaultKeys.push_back("max_iter");
         defaultKeys.push_back("type_output");
         defaultKeys.push_back("outputFile");
         defaultKeys.push_back("number_outputs");
 }
 ConfigFileParser::~ConfigFileParser(){}
 
 std::map<std::string,std::string> ConfigFileParser::getData(){
     return data;
 }
 
 void ConfigFileParser::setData(std::map<std::string,std::string> pData)
 {
     data=pData;
 }
 std::string ConfigFileParser::getFName(){
     return fName;
 }
 
 void ConfigFileParser::parseFile(std::string pFname){
     fName = pFname;
     std::cout<<"Parsing file: " << fName << std::endl;
     std::ifstream file;
     file.open(fName.c_str());
     if (!file)
         throw FileNotFoundException();
     std::string line;
     while (std::getline(file, line))
     {
         std::string temp = line;
         if (temp.empty()) //Empty Line
             continue;
         if(temp.front() =='#') //Comment Line
             continue;
 
         std::istringstream str_line(temp);
         std::string key;
         if( std::getline(str_line, key, '=') )
         {
             std::string value;
 
             if( std::getline(str_line, value) ){
                 if (!key.empty() && !value.empty()) { //Verify that the two values exist
                     data[key] = value;
                     //std::cout << "key: " << key << std::endl;
                     //std::cout << "value: " << value << std::endl;
                 }
                 else
                     throw FileParserException();
             }
         }
     }
     file.close();
 
 
 
 }
 void ConfigFileParser::verify(){
     for(int i=0;i<defaultKeys.size();++i){
         std::string defaultKey = defaultKeys[i];
         valueExistsForKey(defaultKey);
     }
 
 }
 bool ConfigFileParser::valueExistsForKey(std::string key){
     auto iter = data.find(key);
     if (iter == data.end())
         throw FileParserException();
     else
         return true;
 }
diff --git a/CG_Parallel/input_options.txt b/CG_Parallel/input_options.txt
index 93a9ce8..7248a4e 100644
--- a/CG_Parallel/input_options.txt
+++ b/CG_Parallel/input_options.txt
@@ -1,35 +1,28 @@
 #Text file with the options to execute the Conjugate Gradient Solver
 #Authors: Sergio Daniel Hernandez Charpak
 #===========================================
 #----------------Format---------------------
 #-To comment just start a line with the '#' character
 #The format goes by: key=value with no spaces.
 #For keys with several values these are separated with the ',' character
 #Keys are unique
 #===========================================
 #----------------Initial-Conditions-------------
 #-Be careful to write the path with no quotes
 #-Can be:
-#-a Plummer Sphere:'Plummer'
-#-a two body Kepler problem:'2Kepler'
-#-a four body Kepler problem:'4Kepler'
-type_input=Plummer
+#-a tridiagonal matrix:'tridiagonal'
+#-an external file:path_to_the_file
+type_input=tridiagonal
 #----------------General-Physics----------------
-newton_g=0.0044995611
-timestep=0.1
-box_size=50
-softening=10.0
-tree_thres=1.5
-display_f=10
-n_particles=200
-scale_radius=10.0
-n_time_steps=100
+N=100
+tol=1e-10
+max_iter=2000
 #----------------Output-Files----------------
 #-Be careful to write the path with no quotes
 #-Can be:
 #-a text File:'text'
 #-a binary file:'bin'
 type_output=text
 outputFile=testing_1
 number_outputs=1
 #----------------End----------------
diff --git a/CG_Parallel/main.cpp b/CG_Parallel/main.cpp
index 4710ec4..ec5e1ef 100644
--- a/CG_Parallel/main.cpp
+++ b/CG_Parallel/main.cpp
@@ -1,52 +1,118 @@
 /**
  * @file main.cpp
  * @author Sergio Hernandez
  * This file is part of the Conjugate Gradient Project
  *
  * Ths is the entry point of the project.
  *
  */
 
 #include <iostream>
 #include<vector>
 #include "CG_Parallel.hpp"
 #include<mpi/mpi.h>
+#include "ConfigFileParser.hpp"
+/**
+ * Constant to inform the user the correct usage of the program in case of a misuse.
+ */
+#define USAGE "Please enter correctly one argument (a config file). Example: ./CG_Parallel configFile.txt"
+/**
+ * Constant which defines the correct number of arguments the program can receive.
+ */
+#define N_ARGS 2
+
 int main(int argc, char* argv[]) {
     MPI_Init(&argc, &argv);
-    //TODO Temporal - using Tridiagonal matrix
-    int N = 100;
-    std::vector<double> A(N*N,0.0);//Filled with 0.0
-    std::vector<double> b(N, 1.0);//Filled with 1.0
-    for (int i=0; i<N; i++){
-        for (int j=0; j<N; j++){
-            if (j == i+1){
-                if (i < N-1 ) {
-                    A[i + N * j] = 1.0; //Upper
-                }
-            }
-            if (j == i-1){
-                if (i > 0 ){
-                    A[i+N*j] = 1.0; //Downer
+    int rank, size;
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    if(argc!=N_ARGS){
+        std::cout<<USAGE<< std::endl;
+        return 1;
+    }
+    try {
+        int N, max_iter, number_outputs;
+        double tol;
+        std::string type_input, type_output, outputFile;
+        std::vector<double> A;//Filled with 0.0
+        std::vector<double> b;//Filled with 1.0
+
+        std::string fName = argv[1];
+        ConfigFileParser parser = ConfigFileParser();
+        parser.parseFile(fName);
+        parser.verify();
+        std::cout << "Finished parsing the file " << std::endl;
+        //This could be an executer
+        std::map<std::string, std::string> data = parser.getData();
+        //Size of the matrix
+        std::string tempKey = "N";
+        N = stoi(data[tempKey]);
+        std::cout << " N = " << N << std::endl;
+        //Tolerance
+        tempKey = "tol";
+        tol = stof(data[tempKey]);
+        std::cout << " tol = " << tol << std::endl;
+        //max iterations
+        tempKey = "max_iter";
+        max_iter = stoi(data[tempKey]);
+        std::cout << " max_iter = " << max_iter << std::endl;
+        //type input
+        tempKey = "type_input";
+        type_input = data[tempKey];
+        //number_outputs
+        tempKey = "number_outputs";
+        number_outputs = stoi(data[tempKey]);
+        tempKey = "type_output";
+        type_output = data[tempKey];
+        tempKey = "outputFile";
+        outputFile = data[tempKey];
+        if (type_input=="tridiagonal") {
+            std::cout<<"Matrix A is: "<<type_input<< std::endl;
+            //TODO Temporal - using Tridiagonal matrix
+            //int N = 100;
+            A.resize(N*N);
+            b.resize(N,1.0);
+            for (int i = 0; i < N; i++) {
+                for (int j = 0; j < N; j++) {
+                    if (j == i + 1) {
+                        if (i < N - 1) {
+                            A[i + N * j] = 1.0; //Upper
+                        }
+                    }
+                    if (j == i - 1) {
+                        if (i > 0) {
+                            A[i + N * j] = 1.0; //Downer
+                        }
+                    }
+                    if (j == i) {
+                        A[i + N * j] = -2.0; //Main diagonal
+                    }
                 }
             }
-            if (j == i){
-                A[i+N*j] = -2.0; //Main diagonal
+        }
+        std::vector<double> x_0 (N,0.0);
+        std::cout<< "Preparing to solve"<<std::endl;
+        CG_Parallel solver = CG_Parallel(A,b,tol,max_iter);
+        std::tuple<std::vector<double>,int> result = solver.computeCG(x_0);
+        std::vector<double> x = std::get<0>(result);
+        int k = std::get<1>(result);
+        if(rank==0){
+            std::cout << "Solution was found after : "<<k<<" iterations.\n";
+            std::cout<<"Solution x: \n";
+            int last_elem = 10;
+            for(int i=x.size()-last_elem;i<x.size();i++){
+                std::cout<< x[i]<<"\n";
             }
         }
+        MPI_Finalize();
+
     }
-    double tol = 1e-10;
-    int max_iter = 10*N;
-    std::vector<double> x_0 (N,0.0);
-    CG_Parallel solver = CG_Parallel(A,b,tol,max_iter);
-    std::tuple<std::vector<double>,int> result = solver.computeCG(x_0);
-    std::vector<double> x = std::get<0>(result);
-    int k = std::get<1>(result);
-    MPI_Finalize();
-    std::cout << "Solution was found after : "<<k<<" iterations.\n";
-    std::cout<<"Solution x: \n";
-    int last_elem = 10;
-    for(int i=x.size()-last_elem;i<x.size();i++){
-        std::cout<< x[i]<<"\n";
+    catch(const std::runtime_error &e){
+        std::cout << e.what() <<std::endl;
+        MPI_Finalize();
+        return 1;
     }
+
     return 0;
 }
\ No newline at end of file