renaming StochasticProblem file + moved Create from CreatePDESolver

mlmc/src/pdesolver/PDESolver.cpp

 #include "PDESolver.hpp"
 
 
+MatrixGraphs *PDESolver::CreateSolutionMatrixGraphs(Meshes &meshes) {
+    auto disc = this->GetDisc();
+    auto discType = typeid(*disc).name();
+    if (discType == typeid(LagrangeDiscretization).name())
+        return new MatrixGraphs(meshes, *disc);
+    if (discType == typeid(RTLagrangeDiscretization).name()) {
+        auto assemble = this->GetAssemble();
+        auto assembleType = typeid(*assemble).name();
+        if (assembleType == typeid(HybridEllipticAssemble).name())
+            return new MatrixGraphs(meshes, dof(new FaceDoF(1)));
+        if (assembleType == typeid(MixedEllipticAssemble).name())
+            return new MatrixGraphs(meshes, *disc);
+    }
+    if (discType == typeid(DGDiscretization).name())
+        return new CellMatrixGraphs(meshes, *disc);
+    if (discType == typeid(EGDiscretization).name())
+        return new CellVertexMatrixGraphs(meshes, *disc);
+    Exit(string(discType) +" not found")
+}
+
 void EllipticPDESolver::run(SampleSolution &solution) {
     newton(*assemble, solution.U);
 }
@@ -29,14 +49,6 @@ void EllipticPDESolver::computeCost(SampleSolution &solution) {
 void EllipticPDESolver::plotSolution(SampleSolution &solution) {
     if (!plotting) return;
     plotMap.VtkPlot(solution);
-
-    // Todo plot flux
-//    const auto d = dof(new CellDoF(3));
-//    MatrixGraph *fluxMGraph = new MatrixGraph(d, solution.U.GetMesh());
-//    SampleSolution fluxSolution(fluxMGraph);
-//    mout << fluxSolution.U << endl;
-//    assemble->SetFlux(solution.U, fluxSolution.U);
-//    plotMap.VtkPlot(fluxSolution, 3, "CellData");
 }
 
 void TransportPDESolver::run(SampleSolution &solution) {
@@ -70,3 +82,50 @@ TimeSeries TransportPDESolver::createTimeSeries(SampleSolution &solution) {
     double h_max = solution.U.GetMesh().MeshWidth().second;
     return TimeSeries(t0, T, CFL * h_max, "UniformTimeSeries");
 }
+
+PDESolver *PDESolverCreator::Create() {
+    if (_model == "LagrangeElliptic")
+        return new EllipticPDESolver(
+            new LagrangeEllipticAssemble(
+                new LagrangeDiscretization(meshes, _degree),
+                CreateStochasticEllipticProblem(_problem, meshes)
+            )
+        );
+
+    if (_model == "MixedElliptic")
+        return new EllipticPDESolver(
+            new MixedEllipticAssemble(
+                new RTLagrangeDiscretization(meshes, 0, 0),
+                CreateStochasticEllipticProblem(_problem, meshes)
+            )
+        );
+
+    if (_model == "HybridElliptic")
+        return new EllipticPDESolver(
+            new HybridEllipticAssemble(
+                new RTLagrangeDiscretization(meshes, 0, 0),
+                CreateStochasticEllipticProblem(_problem, meshes)
+            )
+        );
+
+    if (_model == "DGElliptic")
+        return new EllipticPDESolver(
+            new DGEllipticAssemble(
+                new DGDiscretization(meshes, _degree),
+                CreateStochasticEllipticProblem(_problem, meshes)
+            )
+        );
+
+    if (_model == "DGTransport")
+        return new TransportPDESolver(
+            new DGTransportAssemble(
+                new DGDiscretization(meshes, _degree),
+                CreateStochasticTransportProblem(_problem, meshes)
+            )
+        );
+
+    if (_model == "PGTransport")
+        return nullptr; // Todo open research question
+
+    Exit(_model + " not found")
+}

mlmc/src/pdesolver/PDESolver.hpp

@@ -79,25 +79,7 @@ public:
         mout.EndBlock(verbose == 0);
     }
 
-    MatrixGraphs *CreateSolutionMatrixGraphs(Meshes &meshes) {
-        auto disc = this->GetDisc();
-        auto discType = typeid(*disc).name();
-        if (discType == typeid(LagrangeDiscretization).name())
-            return new MatrixGraphs(meshes, *disc);
-        if (discType == typeid(RTLagrangeDiscretization).name()) {
-            auto assemble = this->GetAssemble();
-            auto assembleType = typeid(*assemble).name();
-            if (assembleType == typeid(HybridEllipticAssemble).name())
-                return new MatrixGraphs(meshes, dof(new FaceDoF(1)));
-            if (assembleType == typeid(MixedEllipticAssemble).name())
-                return new MatrixGraphs(meshes, *disc);
-        }
-        if (discType == typeid(DGDiscretization).name())
-            return new CellMatrixGraphs(meshes, *disc);
-        if (discType == typeid(EGDiscretization).name())
-            return new CellVertexMatrixGraphs(meshes, *disc);
-        Exit(string(discType) +" not found")
-    }
+    MatrixGraphs *CreateSolutionMatrixGraphs(Meshes &meshes);
 
     void SetQuantity(const std::string &_quantity) {
         this->quantity = _quantity;
@@ -242,52 +224,7 @@ public:
         return *this;
     }
 
-    PDESolver *Create() {
-        if (_model == "LagrangeElliptic")
-            return new EllipticPDESolver(
-                new LagrangeEllipticAssemble(
-                    new LagrangeDiscretization(meshes, _degree),
-                    CreateStochasticEllipticProblem(_problem, meshes)
-                )
-            );
-
-        if (_model == "MixedElliptic")
-            return new EllipticPDESolver(
-                new MixedEllipticAssemble(
-                    new RTLagrangeDiscretization(meshes, 0, 0),
-                    CreateStochasticEllipticProblem(_problem, meshes)
-                )
-            );
-
-        if (_model == "HybridElliptic")
-            return new EllipticPDESolver(
-                new HybridEllipticAssemble(
-                    new RTLagrangeDiscretization(meshes, 0, 0),
-                    CreateStochasticEllipticProblem(_problem, meshes)
-                )
-            );
-
-        if (_model == "DGElliptic")
-            return new EllipticPDESolver(
-                new DGEllipticAssemble(
-                    new DGDiscretization(meshes, _degree),
-                    CreateStochasticEllipticProblem(_problem, meshes)
-                )
-            );
-
-        if (_model == "DGTransport")
-            return new TransportPDESolver(
-                new DGTransportAssemble(
-                    new DGDiscretization(meshes, _degree),
-                    CreateStochasticTransportProblem(_problem, meshes)
-                )
-            );
-
-        if (_model == "PGTransport")
-            return nullptr; // Todo open research question
-
-        Exit(_model + " not found")
-    }
+    PDESolver *Create();
 };
 
 #endif //PDESOLVER_HPP

mlmc/src/problem/StochasticProblem.cpp → mlmc/src/problem/IStochasticProblem.cpp

-#include "StochasticProblem.hpp"
+#include "IStochasticProblem.hpp"
 #include "generators/CirculantEmbedding.hpp"
 #include "generators/HybridFluxGenerator.hpp"
 

mlmc/src/problem/StochasticProblem.hpp → mlmc/src/problem/IStochasticProblem.hpp

-#ifndef STOCHASTICPROBLEM_HPP
-#define STOCHASTICPROBLEM_HPP
+#ifndef ISTOCHASTICPROBLEM_HPP
+#define ISTOCHASTICPROBLEM_HPP
 
 #include "Algebra.hpp"
 #include "montecarlo/Sample.hpp"

mlmc/src/problem/StochasticEllipticProblem.hpp

 #ifndef STOCHASTICELLIPTICPROBLEM_HPP
 #define STOCHASTICELLIPTICPROBLEM_HPP
 
-#include "problem/StochasticProblem.hpp"
+#include "problem/IStochasticProblem.hpp"
 
 
 class IStochasticEllipticProblem : public IStochasticProblem {

mlmc/src/problem/StochasticReactionProblem.hpp

 #ifndef STOCHASTICREACTIONPROBLEM_HPP
 #define STOCHASTICREACTIONPROBLEM_HPP
 
-#include "StochasticProblem.hpp"
+#include "IStochasticProblem.hpp"
 
 
 // Todo rmv

mlmc/src/problem/StochasticTransportProblem.hpp

 #ifndef MLMC_STOCHASTICTRANSPORTPROBLEM_HPP
 #define MLMC_STOCHASTICTRANSPORTPROBLEM_HPP
 
-#include "problem/StochasticProblem.hpp"
+#include "problem/IStochasticProblem.hpp"
 
 
 class IStochasticTransportProblem : public IStochasticProblem {