PDEModelica - GhostCells

almost finished but crashing

Author: Jan Šilar

Compiler/FrontEnd/InstUtil.mo

@@ -8217,12 +8217,11 @@ public function addGhostCells
   input list<SCode.Equation> inEqs;
   output list<tuple<SCode.Element, DAE.Mod>> outCompelts;
   protected list<Absyn.Ident> fieldNamesP;
+  protected list<tuple<SCode.Element, DAE.Mod>> ghostCompelts;
 algorithm
   fieldNamesP := List.fold(inEqs, fieldsInPderEq, {});
-  //TODO: implement
-
-
-   outCompelts := inCompelts;
+  ghostCompelts := List.fold1(inCompelts,addGhostCells2,fieldNamesP,{});
+  outCompelts := listAppend(inCompelts,ghostCompelts);
 end addGhostCells;
 
 function fieldsInPderEq
@@ -8270,6 +8269,82 @@ algorithm
   outExp := inExp;
 end fieldInPderExp;
 
+function addGhostCells2
+  //if name os given variable is in the given array
+  //adds ghost cells for it
+  input tuple<SCode.Element, DAE.Mod> inCompelt;
+  input list<Absyn.Ident> fieldNamesP;
+  input list<tuple<SCode.Element, DAE.Mod>> inGhosts;
+  output list<tuple<SCode.Element, DAE.Mod>> outGhosts;
+algorithm
+  outGhosts := matchcontinue inCompelt
+  local
+    SCode.Ident name;
+    SCode.Prefixes prefixes;
+    SCode.Attributes attributes;
+    Absyn.TypeSpec typeSpec;
+    SCode.Mod modifications;
+    SCode.Comment comment;
+    Option<Absyn.Exp> condition;
+    SCode.SourceInfo info;
+
+    Absyn.ArrayDim arrayDims;
+    SCode.ConnectorType connectorType;
+    SCode.Parallelism parallelism;
+    SCode.Variability variability;
+    Absyn.Direction direction;
+
+    SCode.Final finalPrefix "final prefix";
+    SCode.Each  eachPrefix "each prefix";
+    list<SCode.SubMod> subModLst;
+    Option<Absyn.Exp> binding;
+    SCode.SourceInfo info2;
+
+    DAE.Mod daeMod;
+
+    tuple<SCode.Element, DAE.Mod> ghostL, ghostR;
+
+    case (SCode.COMPONENT(name, prefixes,
+            SCode.ATTR(arrayDims,connectorType,parallelism,
+                       variability, direction, Absyn.FIELD()
+            ), typeSpec,
+            SCode.MOD(finalPrefix, eachPrefix,subModLst,binding,info2)/*modifications*/,
+            comment, condition, info),daeMod)
+      equation
+        listMember(name, fieldNamesP) = true;
+
+        //remove domain from the subModLst:
+        subModLst = List.filterOnFalse(subModLst,isSubModDomainOrStart);
+
+        ghostL = (SCode.COMPONENT(stringAppend(name,".ghostL"), prefixes,
+              SCode.ATTR(arrayDims,connectorType,parallelism,
+             variability, direction, Absyn.NONFIELD()), typeSpec,
+             SCode.MOD(finalPrefix, eachPrefix,subModLst,binding,info2),
+             comment, condition, info),daeMod);
+        ghostR = (SCode.COMPONENT(stringAppend(name,".ghostR"), prefixes,
+             SCode.ATTR(arrayDims,connectorType,parallelism,
+             variability, direction, Absyn.NONFIELD()), typeSpec,
+             SCode.MOD(finalPrefix, eachPrefix,subModLst,binding,info2),
+             comment, condition, info),daeMod);
+      then
+        ghostL::ghostR::inGhosts;
+    else
+      inGhosts;
+  end matchcontinue;
+end addGhostCells2;
+
+function isSubModDomainOrStart
+  input SCode.SubMod subMod;
+  output Boolean isNotDomain;
+algorithm
+  isNotDomain := match subMod
+    case SCode.NAMEMOD(ident="domain") then true;
+    case SCode.NAMEMOD(ident="start") then true;
+    else false;
+  end match;
+end isSubModDomainOrStart;
+
+
 public function elabField
 //For field variables: finds the "domain" modifier,
 //finds domain.N - length of discretized field array
@@ -8304,7 +8379,7 @@ algorithm
       equation
 //        DAE.MOD(finalPrefix = finalPrefix, eachPrefix = eachPrefix, subModLst = subModLst, eqModOption = eqModOption) = inMod;
         //get N from the domain and remove domain from the subModLst:
-        (N, subModLst, SOME(dcr)) = List.fold30(subModLst,domainSearchFun,-1,{},NONE());
+        (N, subModLst, SOME(dcr)) = List.fold30(subModLst,domainSearchFunDAE,-1,{},NONE());
         if (N == -1) then Error.addSourceMessageAndFail(Error.PDEModelica_ERROR,
             {"Domain of the field variable '", name, "' not found."}, inInfo);
         end if;
@@ -8317,7 +8392,7 @@ algorithm
   end match;
 end elabField;
 
-protected function domainSearchFun
+protected function domainSearchFunDAE
 "fold function to find domain modifier in modifiers list"
 //TODO: simplify this function, perhaps not use fold
   input DAE.SubMod subMod;
@@ -8364,7 +8439,7 @@ protected function domainSearchFun
         fail();
     else (subMod::inSubModLst,inN,inCrOpt);
     end matchcontinue;
-end domainSearchFun;
+end domainSearchFunDAE;
 
 protected function findN
 "a map function to find N in domain class modifiers"
@@ -8481,7 +8556,7 @@ algorithm
         equation
           (N,fieldLst) = getDomNFields(inDomFieldLst,domainCr,info);
 //        then list(newEQFun(i, lhs_exp, rhs_exp, domainCr, comment, info, fieldLst) for i in 2:N-1);
-        then creatFieldEqs(lhs_exp, rhs_exp, domainCr, N, comment, info, fieldLst);
+        then creatFieldEqs(lhs_exp, rhs_exp, domainCr, N, fieldLst, comment, info);
       //same as previous but with ".interior"
       case SCode.EQUATION(SCode.EQ_PDE(expLeft = lhs_exp, expRight = rhs_exp,
                   domain = domainCr as Absyn.CREF_QUAL(name, subscripts, Absyn.CREF_IDENT(name="interior")),
@@ -8490,7 +8565,7 @@ algorithm
           domainCr1 = Absyn.CREF_IDENT(name, subscripts);
           (N,fieldLst) = getDomNFields(inDomFieldLst,domainCr1,info);
 //        then list(newEQFun(i, lhs_exp, rhs_exp, domainCr1, comment, info, fieldLst) for i in 2:N-1);
-        then creatFieldEqs(lhs_exp, rhs_exp, domainCr, N, comment, info, fieldLst);
+        then creatFieldEqs(lhs_exp, rhs_exp, domainCr, N, fieldLst, comment, info);
 
         //left boundary extrapolation
 /*        case SCode.EQUATION(SCode.EQ_PDE(expLeft = lhs_exp, expRight = rhs_exp,
@@ -8525,11 +8600,11 @@ algorithm
                   comment = comment, info = info))
         equation
           domainCr1 = Absyn.CREF_IDENT(name, subscripts);
-          (_,fieldLst) = getDomNFields(inDomFieldLst,domainCr1,info);
+          (N,fieldLst) = getDomNFields(inDomFieldLst,domainCr1,info);
           (lhs_exp, _) = Absyn.traverseExp(lhs_exp, extrapFieldTraverseFun, 1);
           (rhs_exp, _) = Absyn.traverseExp(rhs_exp, extrapFieldTraverseFun, 1);
         then
-          {newEQFun(1, lhs_exp, rhs_exp, domainCr1, comment, info, fieldLst)};
+          {newEQFun(1, lhs_exp, rhs_exp, domainCr1, N, true, fieldLst, comment, info)};
       //right boundary condition or extrapolation
       case SCode.EQUATION(SCode.EQ_PDE(expLeft = lhs_exp, expRight = rhs_exp,
                   domain = Absyn.CREF_QUAL(name, subscripts, Absyn.CREF_IDENT(name="right")),
@@ -8540,7 +8615,7 @@ algorithm
           (lhs_exp, _) = Absyn.traverseExp(lhs_exp, extrapFieldTraverseFun, N);
           (rhs_exp, _) = Absyn.traverseExp(rhs_exp, extrapFieldTraverseFun, N);
         then
-          {newEQFun(N, lhs_exp, rhs_exp, domainCr1, comment, info, fieldLst)};
+          {newEQFun(N, lhs_exp, rhs_exp, domainCr1, N, true, fieldLst, comment, info)};
     end match;
 
   outDiscretizedEQs := listAppend(inDiscretizedEQs, newDiscretizedEQs);
@@ -8588,7 +8663,7 @@ end extrapFieldTraverseFun;
 
 
 
-
+/*
 
 //TODO: remove never called:
 protected function matchExtrapAndField
@@ -8615,7 +8690,7 @@ algorithm
   end match;
 
 end matchExtrapAndField;
-
+*/
 protected function getDomNFields
   input DomainFieldsLst inDomFieldLst;
   input Absyn.ComponentRef inDomainCr;
@@ -8718,9 +8793,9 @@ protected function creatFieldEqs "creates list of equations for fields. If the e
   input Absyn.Exp rhs_exp;
   input Absyn.ComponentRef domainCr;
   input Integer N;
+  input List<Absyn.ComponentRef> fieldLst;
   input SCode.Comment comment;
   input SCode.SourceInfo info;
-  input List<Absyn.ComponentRef> fieldLst;
   output List<SCode.Equation> outDiscretizedEQs;
   protected Boolean bl, br;
 algorithm
@@ -8731,12 +8806,13 @@ algorithm
     //case ((_,false),(_,false)) //no pder()
     case (false,false) //no pder()
     then
-      list(newEQFun(i, lhs_exp, rhs_exp, domainCr, comment, info, fieldLst) for i in 1:N);
+      list(newEQFun(i, lhs_exp, rhs_exp, domainCr, N, false, fieldLst, comment, info) for i in 1:N);
     else  //contains some pder()
-      list(newEQFun(i, lhs_exp, rhs_exp, domainCr, comment, info, fieldLst) for i in 2:N-1);
+      list(newEQFun(i, lhs_exp, rhs_exp, domainCr, N, false, fieldLst, comment, info) for i in 1:N);
   end match;
 end creatFieldEqs;
 
+
 protected function hasPderTraverseFun
   input Absyn.Exp inExp;
   input Boolean inHasPder;
@@ -8757,32 +8833,34 @@ protected function newEQFun
   input Absyn.Exp inLhs_exp;
   input Absyn.Exp inRhs_exp;
   input Absyn.ComponentRef domainCr;
+  input Integer N;
+  input Boolean isBC;  //-1 left ghost cell, 0 no ghost cell, 1 right ghost cell
+  input list<Absyn.ComponentRef> fieldLst;
   input SCode.Comment comment;
   input SCode.SourceInfo info;
-  input list<Absyn.ComponentRef> fieldLst;
   output SCode.Equation outEQ;
   protected Absyn.Exp outLhs_exp, outRhs_exp;
 algorithm
-  (outLhs_exp, _) := Absyn.traverseExpTopDown(inLhs_exp,discretizeTraverseFun,(i,fieldLst,domainCr,info,false));
-  (outRhs_exp, _) := Absyn.traverseExpTopDown(inRhs_exp,discretizeTraverseFun,(i,fieldLst,domainCr,info,false));
+  (outLhs_exp, _) := Absyn.traverseExpTopDown(inLhs_exp,discretizeTraverseFun,(i,fieldLst,domainCr,info,false,N,isBC));
+  (outRhs_exp, _) := Absyn.traverseExpTopDown(inRhs_exp,discretizeTraverseFun,(i,fieldLst,domainCr,info,false,N,isBC));
   outEQ := SCode.EQUATION(SCode.EQ_EQUALS(outLhs_exp, outRhs_exp, comment, info));
 end newEQFun;
 
 protected function discretizeTraverseFun
   input Absyn.Exp inExp;
-  input tuple<Integer, list<Absyn.ComponentRef>, Absyn.ComponentRef, SCode.SourceInfo,Boolean> inTup;
+  input tuple<Integer, list<Absyn.ComponentRef>, Absyn.ComponentRef, SCode.SourceInfo,Boolean,Integer,Boolean> inTup;
   output Absyn.Exp outExp;
-  output tuple<Integer, list<Absyn.ComponentRef>, Absyn.ComponentRef, SCode.SourceInfo,Boolean> outTup;
-  protected Integer i;
+  output tuple<Integer, list<Absyn.ComponentRef>, Absyn.ComponentRef, SCode.SourceInfo,Boolean,Integer,Boolean> outTup;
+  protected Integer i,N;
 //   protected String eqDomainName;
   protected list<Absyn.ComponentRef> fieldLst;
   protected SCode.SourceInfo info;
-  protected Boolean skip, failVar;
+  protected Boolean skip, failVar,isBC;
   protected Absyn.ComponentRef domainCr;
   protected Absyn.Ident domName;
 algorithm
   failVar := false;
-  (i, fieldLst, domainCr, info, skip) := inTup;
+  (i, fieldLst, domainCr, info, skip, N, isBC) := inTup;
   Absyn.CREF_IDENT(name = domName) := domainCr;
   if skip then
     outExp := inExp;
@@ -8794,6 +8872,7 @@ algorithm
       Absyn.Ident name, fieldDomainName;
       list<Absyn.Subscript> subscripts;
       Absyn.ComponentRef fieldCr;
+      Absyn.Exp exp, leftVar, rightVar;
     case  Absyn.CREF(Absyn.CREF_QUAL(name = domName, subscripts = {}, componentRef=Absyn.CREF_IDENT(name="x",subscripts={})))
     //coordinate x
     then
@@ -8802,23 +8881,36 @@ algorithm
     //field
       equation
         true = List.isMemberOnTrue(fieldCr,fieldLst,Absyn.crefEqual);
-      then
-        Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i))::subscripts));
+        exp = (if isBC and i == 1 then
+                Absyn.CREF(Absyn.CREF_IDENT(stringAppend(name,".ghostL"), subscripts))  //left BC
+              elseif isBC and i == N then
+                Absyn.CREF(Absyn.CREF_IDENT(stringAppend(name,".ghostR"), subscripts))  //right BC
+              else
+                Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i))::subscripts))  //no BC
+              );
+      then
+        exp;
     case Absyn.CALL(Absyn.CREF_IDENT("pder",{}),Absyn.FUNCTIONARGS({Absyn.CREF(fieldCr as Absyn.CREF_IDENT(name, subscripts)),Absyn.CREF(Absyn.CREF_IDENT(name="x"))},_))
     //pder
       equation
         if not List.isMemberOnTrue(fieldCr,fieldLst,Absyn.crefEqual) then
           failVar = true;
           Error.addSourceMessageAndFail(Error.COMPILER_ERROR,{"Field variable '" +  name + "' has different domain than the equation or is not a field." }, info);
         end if;
-          skip = true;
+        skip = true;
+        leftVar = (if i == 1 then
+                     Absyn.CREF(Absyn.CREF_IDENT(stringAppend(name,".ghostL"), subscripts))
+                   else
+                     Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i+1))::subscripts))
+                  );
+        rightVar = (if i == N then
+                     Absyn.CREF(Absyn.CREF_IDENT(stringAppend(name,".ghostR"), subscripts))
+                   else
+                     Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i+1))::subscripts))
+                  );
         then
           Absyn.BINARY(
-            Absyn.BINARY(
-              Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i+1))::subscripts)),
-              Absyn.SUB(),
-              Absyn.CREF(Absyn.CREF_IDENT(name, Absyn.SUBSCRIPT(Absyn.INTEGER(i-1))::subscripts))
-            ),
+            Absyn.BINARY(leftVar, Absyn.SUB(), rightVar),
             Absyn.DIV(),
             Absyn.BINARY(
               Absyn.INTEGER(2),
@@ -8843,7 +8935,7 @@ algorithm
   if failVar then
     fail();
   end if;
-  outTup := (i, fieldLst, domainCr, info, skip);
+  outTup := (i, fieldLst, domainCr, info, skip, N, isBC);
 end discretizeTraverseFun;
 
 protected function findDomF<T>