diff --git a/ConSol/ConSol/Mesh/MeshBase.cpp b/ConSol/ConSol/Mesh/MeshBase.cpp
index f724957..543be51 100644
--- a/ConSol/ConSol/Mesh/MeshBase.cpp
+++ b/ConSol/ConSol/Mesh/MeshBase.cpp
@@ -1,212 +1,221 @@
 //
 //  MeshBase.cpp
 //  ConserSolver
 //
 //  Created by Fabian Moenkeberg on 04.05.17.
 //  Copyright © 2017 FabianMoenkeberg. All rights reserved.
 //
 
 #include "MeshBase.hpp"
 
 int MeshBase::getNdims(){return ndims;};
 
 std::vector<double> MeshBase::getSize(){return size;};
 
 std::vector<double> MeshBase::getSize(std::vector<int> i){
     int n = i.size();
     std::vector<double> ret(n);
     for (int j = 0; j < n; j++){
         ret[j] = size[j];
     }
     return ret;
 }
 
 double MeshBase::getSize(int i){
     return size[i];
 }
 
 void MeshBase::setBoundaryNeighbours(Configuration config){};
 
 void MeshBase::initialize(BcBase *bc, Configuration config){};
 
 std::vector<std::vector<double> > MeshBase::evalFunc(AbstractFunct *Funct, evaluationMethod evalMethod){
     std::vector<std::vector<double>> ret(0,std::vector<double>(0));
     return ret;
 };
 
 void MeshBase::setStencils(Configuration config){};
 
 std::vector<double> MeshBase::MidPoint(int i){
     std::vector<double> midPts(0);
     return midPts;
 };
 
 std::vector<std::vector<double>> MeshBase::netFlux(NetFlux* numFluxFct, std::vector<std::vector<double>>& U, std::vector<std::vector<std::vector<double> > > &UReconstr, double t, double dt){
     std::vector<std::vector<double>> ret(0,std::vector<double>(0));
     return ret;
     
 };
 
 void MeshBase::netFlux(std::vector<std::vector<double>> &numFlux, NetFlux* numFluxFct, std::vector<std::vector<double>> &U,
                                                  std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t, double dt){
 //    std::vector<std::vector<double>> ret(0,std::vector<double>(0));
 //    return ret;
 
 };
 
 std::vector<int> MeshBase::getInternal(){return this->internal;};
 
 BcBase* MeshBase::getBc(){return bc;};
 
 int MeshBase::getBCMap(int i){return bcMap[i];};
 
 int MeshBase::getBCMap2(int i){return bcMap2[i];};
 
 int MeshBase::getNelem(){return nelem;};
 
 int MeshBase::getNedges(){return nedges;};
 
 std::vector<std::vector<double>> MeshBase::getXCoord(){return xCoord;};
 
 std::vector<std::vector<double>>  MeshBase::getXCoordOfCell(int i){
     std::vector<int> cell = cells[i];
     int nI = (int) cell.size();
     std::vector<std::vector<double>> ret(nI,std::vector<double>(ndims));
     for (int j = 0; j < nI; j++){
         ret[j] = xCoord[cell[j]];
     }
     return ret;
 };
 
 std::vector<double> MeshBase::getXCoord(int i){return xCoord[i];};
 
 std::vector<std::vector<double>> MeshBase::getXCoord(std::vector<int> i){
 	int nI = (int) i.size();
     std::vector<std::vector<double>> ret(nI,std::vector<double>(ndims));
     for (int j = 0; j < nI; j++){
         ret[j] = xCoord[i[j]];
     }
     return ret;
 };
 
 std::vector<std::vector<int>> MeshBase::getCells(){return cells;};
 
 std::vector<int> MeshBase::getCells(int i){return cells[i];};
 
 int MeshBase::getNcellsTot(){
     return nCellsTot;};
 
 int MeshBase::getNcells(){return nCells;};
 
 int MeshBase::getInternal(int i){return internal[i];};
 
 std::vector<int> MeshBase::getC2E(int i) {return c2e[i];};
 
 std::vector<int> MeshBase::getC2E_internal(int i) {return c2e[internal[i]];};
 
 std::vector<std::vector<int>> MeshBase::getStencils(int i){return stencils[i];};
 
 int MeshBase::getRight(int i){return e2c[i][1];};
 
 int MeshBase::getLeft(int i){return e2c[i][0];};
 
 //std::vector<std::vector<int>> &MeshBase::getIndBCLeftIsOut(){return indBCLeftIsOut;};
 //
 //std::vector<std::vector<int>> &MeshBase::getIndBCRightIsOut(){return indBCRightIsOut;};
 
 std::vector<std::vector<int>> &MeshBase::getEdgesAtBC(){return edgesAtBC;};
 
 std::vector<int> &MeshBase::getEdgesAtBC(int i){return edgesAtBC[i];};
 
 double MeshBase::getDxMin(int d) {return dxMin[d];};
 
 std::vector<double> MeshBase::getDxMin() {return dxMin;};
 
 void MeshBase::updateEdges(std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t){bc->updateEdges(UReconstr, this, t);};
 
 void MeshBase::updateEdges(std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t, int i){bc->updateEdges(UReconstr, this, t, i);};
 
 std::vector<std::vector<double>> MeshBase::edge2Vertex(int i){
     std::vector<std::vector<double>> ret(0,std::vector<double>(0));
     return ret;
 };
 
 double MeshBase::getApproxStencilSize(std::vector<int> i){
 //    double ret = 0;
 //    for (auto const& it: i){
 //        ret += sqrt(size[it]);
 //    }
 //    return ret/2;
     double ret = sqrt(size[i[0]]);
     for (auto const& it: i){
         ret = std::min(sqrt(size[it]), ret);
     }
     return ret;
 }
 
 std::vector<int> MeshBase::getNeightbours(int i){ return  neighbours[i];};
 
 std::vector<int> MeshBase::getEdge(int i){return edg[i];};
 
 std::vector<double> MeshBase::getNormal(int i){return normals[i];};
 
 std::vector<double> MeshBase::getDS(int i){return dS[i];};
 
 MeshType MeshBase::getMeshType(){return meshType;};
 
 int MeshBase::getNgc(){return ngc;};
 
 int MeshBase::getNbc(){return bcMap.size()/3;};
 
 int MeshBase::getNbc2(){return bcMap2.size()/3;};
 
 int MeshBase::getNdomainsQUAD(){return nDomainsQUAD;};
 
 int MeshBase::getNdomainsQUADQUAD(){return nDomainsQUADQUAD;};
 
 int MeshBase::getNdomainsRQ(){return nDomainsRQ;};
 
 int MeshBase::getNdomainsRT(){return nDomainsRT;};
 
 int MeshBase::getNdomainsTRI(){return nDomainsTRI;};
 
 int MeshBase::getNdomainsTRIQUAD(){return nDomainsTRIQUAD;};
 
 std::vector<int> MeshBase::getSubmeshCell0(){
     assert(false && "Meshbase: Submesh not implemented for this mesh kind!");
     return std::vector<int>(0);
 };
 
 std::vector<int> MeshBase::getSubmeshEdg0(){
     return submeshEdg0;
 };
 
 std::vector<int> MeshBase::getNx(){
     assert(false && "Meshbase: Nx not implemented for this mesh kind!");
     return std::vector<int>(0);
 };
 
 std::vector<int> MeshBase::getNy(){
     assert(false && "Meshbase: Ny not implemented for this mesh kind!");
     return std::vector<int>(0);
 };
 
 std::vector<double> MeshBase::getDx(){
     assert(false && "Meshbase: Dx not implemented for this mesh kind!");
     return std::vector<double>(0);
 };
 
 std::vector<double> MeshBase::getDy(){
     assert(false && "Meshbase: Dy not implemented for this mesh kind!");
     return std::vector<double>(0);
 };
 
 std::vector<double> MeshBase::getXmin(){
     assert(false && "Meshbase: Xmin not implemented for this mesh kind!");
     return std::vector<double>(0);
 };
 
 std::vector<double> MeshBase::getYmin(){
     assert(false && "Meshbase: Ymin not implemented for this mesh kind!");
     return std::vector<double>(0);
+};
+
+std::vector<double> MeshBase::getMidPt(int iCell){
+    assert(false && "Meshbase: Ymin not implemented for this mesh kind!");
+    return std::vector<double>(0);
+};
+
+int MeshBase::getNinternal(){
+    return internal.size();
 };
\ No newline at end of file
diff --git a/ConSol/ConSol/Mesh/MeshBase.hpp b/ConSol/ConSol/Mesh/MeshBase.hpp
index faf7dac..8cd123c 100644
--- a/ConSol/ConSol/Mesh/MeshBase.hpp
+++ b/ConSol/ConSol/Mesh/MeshBase.hpp
@@ -1,194 +1,198 @@
 //
 //  MeshBase.hpp
 //  ConserSolver
 //
 //  Created by Fabian Moenkeberg on 04.05.17.
 //  Copyright © 2017 FabianMoenkeberg. All rights reserved.
 //
 
 #ifndef MeshBase_hpp
 #define MeshBase_hpp
 
 //class Configuration;
 class NumFlux;
 #include <stdio.h>
 #include <iostream>
 #include "../Mesh/BC/BcBase.hpp"
 #include <vector>
 #include "../Utility/AbstractFunct.hpp"
 //#include "NumFlux.hpp"
 #include "../Flux/NetFlux.hpp"
 //#include "ModelBase.hpp"
 #include "../Base/Configuration.hpp"
 
 //enum evaluationMethod{PTWISE, MEANVALUE};
 
 class MeshBase {
 protected:
     int ndims;
     int nelem;
     int nedges;
     int nCells;
     std::vector<double> xLim;
     std::vector<std::vector<double>> xCoord;
     std::vector<std::vector<int>> cells;
     std::vector<std::vector<double>> dS;
     int nCellsTot;
     int ngc = 0;
     std::vector<std::vector<int>>  neighbours;
     std::vector<double> size;
     std::vector<std::vector<std::vector<int>>> stencils;
     std::vector<int> internal;
     std::vector<std::vector<double>>  normals;
     BcBase *bc;
     std::vector<std::vector<int>> c2e;
     std::vector<std::vector<int>> edg;
     std::vector<std::vector<int>> e2c;
     std::vector<int> bcMap;
     std::vector<int> bcMap2;                                    //split mapping for fast hybrid mesh from two TRI to one QUAD.
     std::vector<std::vector<int>> edgesAtBC;
     std::vector<double> dxMin;
     std::vector<std::vector<double>> flux;
     int nThreads = 1;
     MeshType meshType;
     int nDomainsQUAD;
     int nDomainsTRI;
     int nDomainsTRIQUAD;
     int nDomainsQUADQUAD;
     int nDomainsRQ;
     int nDomainsRT;
     std::vector<int> submeshEdg0;
 public:
     MeshBase(){};
 
     virtual ~MeshBase(){};
 
     virtual void setBoundaryNeighbours(Configuration config);
     
     virtual void initialize(BcBase *bc, Configuration config);
 
     virtual std::vector<std::vector<double> > evalFunc(AbstractFunct *Funct, evaluationMethod evalMethod);
     
     virtual void setStencils(Configuration config);
     
     virtual std::vector<double> MidPoint(int i);
     
     virtual std::vector<std::vector<double>> netFlux(NetFlux* numFluxFct, std::vector<std::vector<double>> &U, std::vector<std::vector<std::vector<double>>> &UReconstr, double t, double dt);
 
     virtual void netFlux(std::vector<std::vector<double>> &numFlux, NetFlux* numFluxFct, std::vector<std::vector<double>> &U,
                                                      std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t, double dt);
 
     int getNdims();
     
     std::vector<double> getSize();
 
     std::vector<double> getSize(std::vector<int> i);
 
     double getSize(int i);
 
     double getApproxStencilSize(std::vector<int> i);
     
     std::vector<int> getInternal();
     
     int getInternal(int i);
+
+    int getNinternal();
     
     BcBase* getBc();
 
     int getBCMap(int i);
 
     int getBCMap2(int i);
 
     int getNelem();
 
     int getNedges();
     
     std::vector<std::vector<double>> getXCoord();
     
     std::vector<double>  getXCoord(int i);
 
     virtual std::vector<std::vector<double>>  getXCoordOfCell(int i);
     
     std::vector<std::vector<double>>  getXCoord(std::vector<int> i);
     
     std::vector<std::vector<int>> getCells();
     
     std::vector<int> getCells(int i);
     
     int getNcellsTot();
     
     int getNcells();
 
     std::vector<int> getC2E(int i);
 
     std::vector<int> getC2E_internal(int i);
 
     std::vector<std::vector<int>> getStencils(int i);
 
 //    std::vector<std::vector<int>> &getIndBCLeftIsOut();
 //
 //    std::vector<std::vector<int>> &getIndBCRightIsOut();
 
     int getRight(int i);
 
     int getLeft(int i);
 
     double getDxMin(int d);
 
     std::vector<double> getDxMin();
 
     void updateEdges(std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t);
 
     void updateEdges(std::vector<std::vector<std::vector<std::vector<double>>>> &UReconstr, double t, int i);
 
     virtual std::vector<std::vector<double>> edge2Vertex(int i);
 
     std::vector<std::vector<int>> &getEdgesAtBC();
 
     std::vector<int> &getEdgesAtBC(int i);
 
     std::vector<int> getNeightbours(int i);
 
     std::vector<int> getEdge(int i);
 
     std::vector<double> getNormal(int i);
 
     std::vector<double> getDS(int i);
 
     MeshType getMeshType();
 
     int getNgc();
 
     int getNbc();
 
     int getNbc2();
 
     int getNdomainsQUAD();
 
     int getNdomainsQUADQUAD();
 
     int getNdomainsRQ();
 
     int getNdomainsRT();
 
     int getNdomainsTRI();
 
     int getNdomainsTRIQUAD();
 
     virtual std::vector<int> getSubmeshCell0();
 
     virtual std::vector<int> getSubmeshEdg0();
 
     virtual std::vector<int> getNx();
 
     virtual std::vector<int> getNy();
 
     virtual std::vector<double> getDx();
 
     virtual std::vector<double> getDy();
 
     virtual std::vector<double> getXmin();
 
     virtual std::vector<double> getYmin();
+
+    virtual std::vector<double> getMidPt(int iCell);
 };
 
 #endif /* MeshBase_hpp */