dg : replace 0Outcondition by OutsideValueCondition

Solver/dgConservationLaw.cpp

 #include "dgConservationLaw.h"
 #include "function.h"
-class dgBoundaryCondition0Out : public dgBoundaryCondition {
+class dgBoundaryConditionOutsideValue : public dgBoundaryCondition {
   dgConservationLaw &_claw;
+  std::string _outsideValueFunctionName;
   class term : public dataCacheDouble {
     dataCacheMap cacheMapRight; // new cacheMap to  pass to the Riemann solver
     dataCacheDouble &solutionRight;
     dataCacheDouble &solutionLeft;
+    dataCacheDouble &outsideValue;
     dataCacheDouble *riemannSolver;
     dgConservationLaw &_claw;
     public:
-    term(dgConservationLaw &claw, dataCacheMap &cacheMapLeft):
+    term(dgConservationLaw &claw, dataCacheMap &cacheMapLeft,const std::string outsideValueFunctionName):
       solutionRight(cacheMapRight.provideData("Solution")),
       solutionLeft(cacheMapLeft.get("Solution",this)),
+      outsideValue(cacheMapLeft.get(outsideValueFunctionName,this)),
       _claw(claw)
     {
       riemannSolver=_claw.newRiemannSolver(cacheMapLeft,cacheMapRight);
@@ -20,18 +23,20 @@ class dgBoundaryCondition0Out : public dgBoundaryCondition {
     void _eval() {
       if(_value.size1()!=solutionLeft().size1()){
         //adjust sizes
-        solutionRight.set(fullMatrix<double>(solutionLeft().size1(),_claw.nbFields()));
         _value = fullMatrix<double>(solutionLeft().size1(),_claw.nbFields());
       }
+      solutionRight.set(outsideValue());
       for(int i=0;i<_value.size1(); i++)
         for(int j=0;j<_value.size2(); j++)
           _value(i,j) = (*riemannSolver)(i,j*2);
     }
   };
   public:
-  dgBoundaryCondition0Out(dgConservationLaw &claw): _claw(claw) {}
+  dgBoundaryConditionOutsideValue(dgConservationLaw &claw,const std::string outsideValueFunctionName): _claw(claw),
+    _outsideValueFunctionName(outsideValueFunctionName)
+  { }
   dataCacheDouble *newBoundaryTerm(dataCacheMap &cacheMapLeft) const {
-    return new term(_claw,cacheMapLeft);
+    return new term(_claw,cacheMapLeft,_outsideValueFunctionName);
   }
 };
 
@@ -56,8 +61,8 @@ class dgBoundaryCondition0Flux : public dgBoundaryCondition {
   }
 };
 
-dgBoundaryCondition *dgBoundaryCondition::new0OutCondition(dgConservationLaw &claw) {
-  return new dgBoundaryCondition0Out(claw);
+dgBoundaryCondition *dgBoundaryCondition::newOutsideValueCondition(dgConservationLaw &claw,const std::string outsideValueFunctionName) {
+  return new dgBoundaryConditionOutsideValue(claw,outsideValueFunctionName);
 }
 dgBoundaryCondition *dgBoundaryCondition::new0FluxCondition(dgConservationLaw &claw) {
   return new dgBoundaryCondition0Flux(claw);

Solver/dgConservationLaw.h

@@ -17,7 +17,7 @@ class dgBoundaryCondition {
   virtual ~dgBoundaryCondition () {}
   virtual dataCacheDouble *newBoundaryTerm(dataCacheMap &cacheMapLeft) const = 0;
   //a generic boundary condition using the Riemann solver of the conservation Law
-  static dgBoundaryCondition *new0OutCondition(dgConservationLaw &claw);
+  static dgBoundaryCondition *newOutsideValueCondition(dgConservationLaw &claw,const std::string outsideValueFunctionName);
   static dgBoundaryCondition *new0FluxCondition(dgConservationLaw &claw);
 };
 

Solver/dgMainTest.cpp

@@ -59,17 +59,21 @@ int main(int argc, char **argv){
   }
   print("init.pos",*elementGroups[0],&sol(0,0));
 
-  //advection
+
   fullMatrix<double> advectionSpeed(3,1);
   advectionSpeed(0,0)=0.15;
   advectionSpeed(1,0)=0.05;
   advectionSpeed(2,0)=0.;
-
   function::add("advectionSpeed",function::newFunctionConstant(advectionSpeed));
 
   dgConservationLaw *law = dgNewConservationLawAdvection("advectionSpeed");
-  law->addBoundaryCondition("Left",dgBoundaryCondition::new0OutCondition(*law));
-  law->addBoundaryCondition("Right",dgBoundaryCondition::new0OutCondition(*law));
+
+  fullMatrix<double> outsideValue(1,1);
+  outsideValue(0,0)=0;
+  function::add("outsideValue",function::newFunctionConstant(outsideValue));
+  law->addBoundaryCondition("Left",dgBoundaryCondition::newOutsideValueCondition(*law,"outsideValue"));
+  law->addBoundaryCondition("Right",dgBoundaryCondition::newOutsideValueCondition(*law,"outsideValue"));
+
   law->addBoundaryCondition("Top",dgBoundaryCondition::new0FluxCondition(*law));
   law->addBoundaryCondition("Bottom",dgBoundaryCondition::new0FluxCondition(*law));