Restructured Interfaces

src/coupled/problem/CoupledProblem.hpp

@@ -4,15 +4,90 @@
 #include "problem/ElasticityProblem.hpp"
 #include "problem/ElphyProblem.hpp"
 
-class CoupledProblem : public ElasticityProblem, public IElphyProblem{
+class CoupledProblem : public ElasticityProblem, public ElphyProblem{
+protected:
+  int coupledVerbose() const {
+    return std::max(ElasticityProblem::verbose, ElphyProblem::verbose);
+  }
+
+#define elphyMeshName ElphyProblem::meshesName
+#define elphyMeshes ElphyProblem::meshes
+#define elphyGeo ElphyProblem::cGeo
+
+#define mechMeshName ElasticityProblem::meshesName
+#define mechMeshes ElasticityProblem::meshes
+#define mechGeo ElasticityProblem::cGeo
 public:
   CoupledProblem() = default;
   CoupledProblem(bool at, std::array<double, 4> sigmaParams)
-      : ElasticityProblem(), IElphyProblem(at, sigmaParams) {}
+      : ElasticityProblem(), ElphyProblem(at, sigmaParams) {}
   CoupledProblem(const std::string& matName, const std::vector<double>& matParameters, bool at=true)
-      : ElasticityProblem(matName, matParameters), IElphyProblem(at) {}
+      : ElasticityProblem(matName, matParameters), ElphyProblem(at) {}
   CoupledProblem(const std::string& matName, const std::vector<double>& matParameters, bool at, std::array<double, 4> sigmaParams)
-      : ElasticityProblem(matName, matParameters), IElphyProblem(at, sigmaParams) {};
+      : ElasticityProblem(matName, matParameters), ElphyProblem(at, sigmaParams) {
+  };
+
+  void CreateMeshes()=delete;
+  void CreateMeshes(MeshesCreator& creator) = delete;
+
+  const std::string &ElphyMeshName() const{
+    return elphyMeshName;
+  }
+
+  const std::string &MechMeshName() const{
+    return mechMeshName;
+  }
+  void CreateElphyMesh(MeshesCreator& creator){
+    {
+      elphyGeo = CreateCoarseGeometryShared(elphyMeshName);
+      elphyMeshes = creator.WithCoarseGeometry(elphyGeo).
+          WithCommSplit(ElphyProblem::commSplit).CreateShared();
+    }
+  }
+  void CreateMeshMesh(MeshesCreator& creator){
+    {
+      mechGeo = CreateCoarseGeometryShared(mechMeshName);
+      mechMeshes = creator.WithCoarseGeometry(mechGeo).
+          WithCommSplit(ElasticityProblem::commSplit).CreateShared();
+    }
+  }
+
+
+  const CoarseGeometry &ElphyDomain() const { return *elphyGeo; };
+
+  const Meshes &GetElphyMeshes() const { return *elphyMeshes; }
+
+  const Mesh &GetElphyMesh(int level) const { return (*elphyMeshes)[level]; }
+
+  const Mesh &GetElphyMesh(LevelPair level) const { return (*elphyMeshes)[level]; }
+
+
+  const CoarseGeometry &MechDomain() const { return *mechGeo; };
+
+  const Meshes &GetMechMeshes() const { return *mechMeshes; }
+
+  const Mesh &GetMechMesh(int level) const { return (*mechMeshes)[level]; }
+
+  const Mesh &GetMechMesh(LevelPair level) const { return (*mechMeshes)[level]; }
+
+  virtual std::string Name() const override = 0;
+
+  string Evaluate(const Vector &solution) const override {
+    return EvaluateElphy(solution) + "\n" + EvaluateMech(solution);
+  }
+
+  vector<double> EvaluationResults(const Vector &solution) const override {
+    auto elphyResults = EvaluationResultsElphy(solution);
+    auto mechResults = EvaluationResultsMech(solution);
+
+    return mechResults;
+  }
+
+  virtual string EvaluateElphy(const Vector &solution) const { return ""; }
+  virtual string EvaluateMech(const Vector &solution) const { return ""; }
+
+  virtual vector<double> EvaluationResultsElphy(const Vector &solution) const { return {}; }
+  virtual vector<double> EvaluationResultsMech(const Vector &solution) const { return {}; }
 };
 
 
@@ -112,9 +187,12 @@ public:
     return elphyProblem->EvaluationResults(solution);
   }
 
-  string Evaluate(const Vector &solution) const override {
+  virtual string EvaluateElphy(const Vector &solution) const{
     return elphyProblem->Evaluate(solution);
   }
+  virtual string EvaluateMech(const Vector &solution) const {
+    return mechProblem->Evaluate(solution);
+  }
 
   double Potential(double time, const Point &x) const override {
     return elphyProblem->Potential(time, x);

src/coupled/problem/PhysiologicalProblems.cpp

@@ -5,7 +5,7 @@
 vector<double> ContractingVentricleProblem::EvaluationResults(const Vector &solution) const {
   auto apexPot = findPotential(solution, {ventricleApex});
 
-  mout.PrintInfo("LeftVentricle", verbose,
+  mout.PrintInfo("LeftVentricle", coupledVerbose(),
                  PrintInfoEntry("ApexPotential", apexPot, 1));
   return {};
 }

src/coupled/problem/PhysiologicalProblems.hpp

@@ -7,6 +7,7 @@
 
 
 class ContractingVentricleProblem : public CoupledProblem {
+  using ElasticityProblem::verbose;
   // Robin Boundary
   //std::array<double, 8> robinParams{10.0, 0.0, 5.0, 0.0, 1500.0, 1e-4, 1.0, 0.0};
   std::array<double, 8> robinParams{0.2, 0.0, 5.0e-3, 0.0, 1500.0, 1e-4, 1.0, 0.0};