diff --git a/ConSol/ConSol/Mesh/BC/OpenFlowBC.cpp b/ConSol/ConSol/Mesh/BC/OpenFlowBC.cpp
index af1b213..1ddee2e 100644
--- a/ConSol/ConSol/Mesh/BC/OpenFlowBC.cpp
+++ b/ConSol/ConSol/Mesh/BC/OpenFlowBC.cpp
@@ -1,154 +1,156 @@
 //
 // Created by Fabian Moenkeberg on 2019-11-28.
 //
 
 #include "OpenFlowBC.hpp"
 
 void OpenFlowBC::initialize(MeshBase *mesh, Configuration config) {
     gamma = 1.4;
     U0.resize(4);
     double r_in = 1;
     double u1_in = std::sqrt(gamma)*M*cos(alpha);
     double u2_in =std::sqrt(gamma)*M*sin(alpha);
     double p_in = 1;
 
     double E_in = p_in/(gamma - 1) + 0.5*(u1_in*u1_in+u2_in*u2_in)*r_in;
 
     U0 = {r_in, r_in*u1_in, r_in*u2_in, E_in};
 }
 
 void OpenFlowBC::updateBoundary(std::vector<std::vector<double> > &U, MeshBase *mesh, double t){
     std::vector<double> n;
     int nBC = mesh->getNbc();
     for (int i = 0; i < nBC; i++){
         U[mesh->getBCMap(3*i+0)] = U[mesh->getBCMap(3*i+1)];
         int iEdge = mesh->getBCMap(3*i+2);
         if (iEdge == -1){ // internal hybrid update
             U[mesh->getBCMap(3 * i + 0)] = U[mesh->getBCMap(3 * i + 1)];
         }else {
             std::vector<int> edgesAtBC = mesh->getEdgesAtBC(iEdge);
             switch (edgesAtBC[1]) {
                 case 2: { // slipwall BC
                     n = mesh->getNormal(edgesAtBC[0]);
                     if (edgesAtBC[2] == 1) { //means left side of edge is out & normal is INWARDS pointing
                         n[0] = -n[0];
                         n[1] = -n[1];
                     }
 
                     flux_slipWall(U[mesh->getBCMap(3 * i + 1)], n, U[mesh->getBCMap(3 * i + 0)]);
                     break;
                 }
                 case 0: { // means inflow BC
                     n = mesh->getNormal(edgesAtBC[0]);
                     if (edgesAtBC[2] == 1) { //means left side of edge is out & normal is INWARDS pointing
                         n[0] = -n[0];
                         n[1] = -n[1];
                     }
 
                     U[mesh->getBCMap(3 * i + 0)] = flux_farfield(U[mesh->getBCMap(3 * i + 1)], n, U0);
                     break;
                 }
                 case 1: { // means outflow BC
                     n = mesh->getNormal(edgesAtBC[0]);
                     if (edgesAtBC[2] == 1) { //means left side of edge is out & normal is INWARDS pointing
                         n[0] = -n[0];
                         n[1] = -n[1];
                     }
 //                    U[mesh->getBCMap(3 * i + 0)] = flux_farfield(U[mesh->getBCMap(3 * i + 1)], n, U[mesh->getBCMap(3 * i + 1)]);
 //                    U[mesh->getBCMap(3 * i + 0)] = flux_outflow(U[mesh->getBCMap(3 * i + 1)], n,p0);
                     U[mesh->getBCMap(3 * i + 0)] = U[mesh->getBCMap(3 * i + 1)];
                     break;
                 }
             }
         }
     }
 
     int nBC2 = mesh->getNbc2()/2;
     int dimSys = mesh->getNelem();
     std::vector<double> tmp;
     std::vector<double> tmp2;
     for (int i = 0; i < nBC2; i++){
         tmp = U[mesh->getBCMap2(3*i + 1)];
         tmp2 = U[mesh->getBCMap2(3*(i + nBC2) + 1)];
         for (int j = 0; j < dimSys; j++){
             U[mesh->getBCMap2(3*i + 0)][j] = 0.5*(tmp[j] + tmp2[j]);
         }
     }
 }
 
 void OpenFlowBC::updateEdges(std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, MeshBase *mesh, double t){
     std::vector<std::vector<int>> edgesAtBC = mesh->getEdgesAtBC();
     int nelem = mesh->getNelem();
     int nQuad = UReconstr[0][0].size();
     int nEdgesBC = edgesAtBC.size();
     std::vector<double> n;
 
     for(int i = 0; i < nEdgesBC; i++) {
         nQuad = UReconstr[0][edgesAtBC[i][0]].size();
         for (int k = 0; k < nQuad; k++){
             if ((edgesAtBC[i][1] == 2)){// slipwall BC
                 if (edgesAtBC[i][2] == 0) { //means right side of edge is out & normal is OUTWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
                     flux_slipWall(UReconstr[1][edgesAtBC[i][0]][k], n, UReconstr[0][edgesAtBC[i][0]][k]);
                 }else{//means left side of edge is out & normal is INWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
                     n[0] = -n[0];
                     n[1] = -n[1];
                     flux_slipWall(UReconstr[0][edgesAtBC[i][0]][k], n, UReconstr[1][edgesAtBC[i][0]][k]);
                 }
             }else if ((edgesAtBC[i][1] == 0)){ // means inflow
                 if (edgesAtBC[i][2] == 0) { //means right side of edge is out & normal is OUTWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
                     UReconstr[0][edgesAtBC[i][0]][k] = flux_farfield(UReconstr[1][edgesAtBC[i][0]][k], n, U0);
                 }else{//means left side of edge is out & normal is INWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
                     n[0] = -n[0];
                     n[1] = -n[1];
                     UReconstr[1][edgesAtBC[i][0]][k] = flux_farfield(UReconstr[0][edgesAtBC[i][0]][k], n, U0);
                 }
             }else if ((edgesAtBC[i][1] == 1)){ // means outflow
                 if (edgesAtBC[i][2] == 0) { //means right side of edge is out & normal is OUTWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
 //                    UReconstr[0][edgesAtBC[i][0]][k] = flux_farfield(UReconstr[1][edgesAtBC[i][0]][k], n, U0);
-                    UReconstr[0][edgesAtBC[i][0]][k] = UReconstr[1][edgesAtBC[i][0]][k];
+//                    UReconstr[0][edgesAtBC[i][0]][k] = UReconstr[1][edgesAtBC[i][0]][k];
+                    UReconstr[0][edgesAtBC[i][0]][k] = U0;
                 }else{//means left side of edge is out & normal is INWARDS pointing
                     n = mesh->getNormal(edgesAtBC[i][0]);
                     n[0] = -n[0];
                     n[1] = -n[1];
 //                    UReconstr[1][edgesAtBC[i][0]][k] = flux_farfield(UReconstr[0][edgesAtBC[i][0]][k], n, U0);
-                    UReconstr[1][edgesAtBC[i][0]][k] = UReconstr[0][edgesAtBC[i][0]][k];
+//                    UReconstr[1][edgesAtBC[i][0]][k] = UReconstr[0][edgesAtBC[i][0]][k];
+                    UReconstr[1][edgesAtBC[i][0]][k] = U0;
                 }
             }
         }
 
         if ((edgesAtBC[i][1] == 11)){ // means hybrid Connection BC
             if (edgesAtBC[i][2] == 0) { //means right side of edge is out & normal is OUTWARDS pointing
                 for (int k = 0; k < nQuad; k++){
                     UReconstr[0][edgesAtBC[i][0]][k] = UReconstr[0][edgesAtBC[i][3]][0];
                 }
             }else{//means left side of edge is out & normal is INWARDS pointing
                 for ( int l = 0; l < nelem; l++){
                     UReconstr[1][edgesAtBC[i][0]][0][l] = 0;
                     for (int k = 0; k < nQuad; k++){
                         UReconstr[1][edgesAtBC[i][0]][0][l] += UReconstr[1][edgesAtBC[i][3]][k][l]/nQuad;
                     }
                 }
 
             }
         }else if ((edgesAtBC[i][1] == 14)){ // means hybrid QUADQUAD 2 QUAD or QUAD 2 QUADQUAD Connection BC
             if (edgesAtBC[i][2] == 0) { //means right side of edge is out & normal is OUTWARDS pointing
                 UReconstr[0][edgesAtBC[i][0]]= UReconstr[1][edgesAtBC[i][3]];
             }else{//means left side of edge is out & normal is INWARDS pointing
                 UReconstr[1][edgesAtBC[i][0]]= UReconstr[0][edgesAtBC[i][3]];
             }
         }
     }
 }
 
 void OpenFlowBC::flux_slipWall(std::vector<double> U, std::vector<double> n, std::vector<double> &ret){
     ret = U;
     std::vector<double> V_in{U[1]/U[0],U[2]/U[0]};
     double vn = V_in[0]*n[0] + V_in[1]*n[1];
     ret[1] = U[0]*(V_in[0]-2*vn*n[0]);
     ret[2] = U[0]*(V_in[1]-2*vn*n[1]);
 }
\ No newline at end of file