- remove unused code

- rewrite collect zero crossings function interface to run it only once(not in lower and matching)

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@8057 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Jens Frenkel

Compiler/BackEnd/BackendDAECreate.mo

@@ -87,7 +87,7 @@ protected
   BackendDAE.AliasVariables aliasVars "hash table with alias vars' replacements (a=b or a=-b)";
   list<BackendDAE.Equation> eqns,reqns,ieqns,algeqns,algeqns1,ialgeqns,multidimeqns,imultidimeqns,eqns_1;
   list<BackendDAE.MultiDimEquation> aeqns,aeqns1,iaeqns;
-  list<DAE.Algorithm> algs,algs_1,ialgs;
+  list<DAE.Algorithm> algs,ialgs;
   list<BackendDAE.WhenClause> whenclauses,whenclauses_1;
   BackendDAE.EquationArray eqnarr,reqnarr,ieqnarr;
   array<BackendDAE.MultiDimEquation> arr_md_eqns;
@@ -127,13 +127,12 @@ algorithm
   vars_1 := detectImplicitDiscrete(vars, eqns);
   vars_1 := detectImplicitDiscreteAlgs(vars_1,knvars, algs);
   eqns_1 := sortEqn(eqns);
-  (zero_crossings,eqns_1,aeqns,whenclauses_1,algs_1) := findZeroCrossings(vars_1,knvars,eqns_1,aeqns,whenclauses_1,algs);
   eqnarr := BackendDAEUtil.listEquation(eqns_1);
   reqnarr := BackendDAEUtil.listEquation(reqns);
   ieqnarr := BackendDAEUtil.listEquation(ieqns);
   arr_md_eqns := listArray(aeqns);
-  algarr := listArray(algs_1);
-  einfo := Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,zero_crossings),(SOME(functionTree),{DAE.NORM_INLINE()}));
+  algarr := listArray(algs);
+  einfo := Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,{}),(SOME(functionTree),{DAE.NORM_INLINE()}));
   aliasVars := BackendDAEUtil.emptyAliasVariables();
   outBackendDAE := BackendDAE.DAE(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls);
 end lower;
@@ -2788,21 +2787,39 @@ end differentZeroCrossing;
 public function findZeroCrossings "function: findZeroCrossings
 
   This function finds all zerocrossings in the list of equations and
-  the list of when clauses. Used in lower2.
+  the list of when clauses.
 "
-  input BackendDAE.Variables vars;
-  input BackendDAE.Variables knvars;
-  input list<BackendDAE.Equation> eq;
-  input list<BackendDAE.MultiDimEquation> multiDimEqs;
-  input list<BackendDAE.WhenClause> wc;
-  input list<DAE.Algorithm> algs;
-  output list<BackendDAE.ZeroCrossing> res_1;
-  output list<BackendDAE.Equation> outEquationLst;
-  output list<BackendDAE.MultiDimEquation> outMultiDimEqs;
-  output list<BackendDAE.WhenClause> outWhenClauseLst;
-  output list<DAE.Algorithm> outAlgs;
+    input BackendDAE.BackendDAE inDAE;
+    output BackendDAE.BackendDAE outDAE;
 algorithm
-  (res_1,outEquationLst,outMultiDimEqs,outWhenClauseLst,outAlgs) := findZeroCrossings2(vars, knvars,eq,multiDimEqs,0, wc, 0, algs,0,{},0);
+  outDAE:=
+  match (inDAE)
+    local
+      BackendDAE.Variables vars,knvars,exobj;
+      BackendDAE.AliasVariables av;
+      BackendDAE.EquationArray eqns,remeqns,inieqns,eqns1;
+      array<BackendDAE.MultiDimEquation> arreqns,arreqns1;
+      array<DAE.Algorithm> algorithms,algorithms1;
+      BackendDAE.EventInfo einfo,einfo1;
+      BackendDAE.ExternalObjectClasses eoc;
+      list<BackendDAE.WhenClause> whenclauses,whenclauses1;
+      list<BackendDAE.Equation> eqs_lst,eqs_lst1;
+      list<BackendDAE.MultiDimEquation> arreqns_lst,arreqns_lst1;
+      list<DAE.Algorithm> algs_lst,algs_lst1;      
+      list<BackendDAE.ZeroCrossing> zero_crossings;
+    case (BackendDAE.DAE(vars,knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc))
+      equation
+        eqs_lst = BackendDAEUtil.equationList(eqns);
+        arreqns_lst = arrayList(arreqns);
+        algs_lst = arrayList(algorithms);        
+        (zero_crossings,eqs_lst1,arreqns_lst1,whenclauses1,algs_lst1) = findZeroCrossings2(vars, knvars,eqs_lst,arreqns_lst,0, whenclauses, 0, algs_lst,0,{},0);
+        eqns1 = BackendDAEUtil.listEquation(eqs_lst1);
+        arreqns1 = listArray(arreqns_lst);    
+        algorithms1 = listArray(algs_lst1);    
+        einfo1 = BackendDAE.EVENT_INFO(whenclauses1,zero_crossings);        
+      then
+        (BackendDAE.DAE(vars,knvars,exobj,av,eqns1,remeqns,inieqns,arreqns1,algorithms1,einfo1,eoc));
+  end match; 
 end findZeroCrossings;
 
 protected function findZeroCrossings2 "function: findZeroCrossings2

Compiler/BackEnd/BackendDAETransform.mo

@@ -123,10 +123,6 @@ algorithm
       list<BackendDAE.MultiDimEquation> ae_lst;
       array<BackendDAE.Value> vec1,vec2;
       BackendDAE.MatchingOptions match_opts;
-      BackendDAE.ExternalObjectClasses eoc;
-      list<BackendDAE.WhenClause> whenclauses;
-      list<BackendDAE.ZeroCrossing> zero_crossings;
-      list<DAE.Algorithm> algs;
     /* fail case if daelow is empty */
     case ((dae as BackendDAE.DAE(orderedVars = vars,orderedEqs = eqns)),m,mt,match_opts,inFunctions)
       equation
@@ -155,16 +151,7 @@ algorithm
         /* NOTE: Here it could be possible to run removeSimpleEquations again, since algebraic equations
         could potentially be removed after a index reduction has been done. However, removing equations here
         also require that e.g. zero crossings, array equations, etc. must be recalculated. */       
-        (dae as BackendDAE.DAE(v,kv,exv,av,e,re,ie,ae,al,ev,eoc),_,_) = BackendDAEOptimize.removeSimpleEquations(dae,inFunctions,SOME(m),SOME(mt)); 
-        BackendDAE.EVENT_INFO(whenClauseLst=whenclauses) = ev;
-        e_lst = BackendDAEUtil.equationList(e);
-        ae_lst = arrayList(ae);
-        algs = arrayList(al);
-        (zero_crossings,e_lst,ae_lst,whenclauses,algs) = BackendDAECreate.findZeroCrossings(v,kv,e_lst,ae_lst,whenclauses,algs);
-        e = BackendDAEUtil.listEquation(e_lst);
-        ae = listArray(ae_lst);    
-        einfo = BackendDAE.EVENT_INFO(whenclauses,zero_crossings); 
-        dae_1 = BackendDAE.DAE(v,kv,exv,av,e,re,ie,ae,al,einfo,eoc); 
+        (dae_1,_,_) = BackendDAEOptimize.removeSimpleEquations(dae,inFunctions,SOME(m),SOME(mt)); 
         m_1 = BackendDAEUtil.incidenceMatrix(dae_1, BackendDAE.NORMAL())
         "Rerun matching to get updated assignments and incidence matrices
          TODO: instead of rerunning: find out which equations are removed
@@ -481,7 +468,7 @@ algorithm
 
     case (dae,m,mt,nv,nf,i,ass1,ass2,(BackendDAE.INDEX_REDUCTION(),eq_cons,r_simple),inFunctions,derivedAlgs,derivedMultiEqn)
       equation
-        ((dae as BackendDAE.DAE(BackendDAE.VARIABLES(_,_,_,_,nv_1),BackendDAE.VARIABLES(_,_,_,_,nkv),_,_,eqns,_,_,_,_,_,_)),m,mt,derivedAlgs1,derivedMultiEqn1) = reduceIndexDummyDer(dae, m, mt, nv, nf, i, inFunctions,derivedAlgs,derivedMultiEqn) 
+        (dae,m,mt,derivedAlgs1,derivedMultiEqn1) = reduceIndexDummyDer(dae, m, mt, nv, nf, i, inFunctions,derivedAlgs,derivedMultiEqn) 
         "path_found failed, Try index reduction using dummy derivatives.
          When a constraint exist between states and index reduction is needed
          the dummy derivative will select one of the states as a dummy state
@@ -492,6 +479,7 @@ algorithm
          In the dummy derivative method this equation is added and the original equation
          u1=u2 is kept. This is not the case for the original pantilides algorithm, where
          the original equation is removed from the system." ;
+        eqns = BackendEquation.daeEqns(dae);
         nf_1 = BackendDAEUtil.equationSize(eqns) "and try again, restarting. This could be optimized later. It should not
                                    be necessary to restart the matching, according to Bernard Bachmann. Instead one
                                    could continue the matching as usual. This was tested (2004-11-22) and it does not
@@ -501,6 +489,7 @@ algorithm
                                    2004-12-29 PA. This was a bug, assignment lists needed to be expanded with the size
                                    of the system in order to work. SO: Matching is not needed to be restarted from
                                    scratch." ;
+        nv_1 = BackendVariable.varsSize(BackendVariable.daeVars(dae));
         nvd = nv_1 - nv;
         ass1_1 = assignmentsExpand(ass1, nvd);
         ass2_1 = assignmentsExpand(ass2, nvd);

Compiler/BackEnd/BackendDAEUtil.mo

@@ -3966,7 +3966,7 @@ algorithm
         e_1 = e - 1;
         eqn = equationNth(daeeqns, e_1);
         row = incidenceRow(vars, eqn,wc);
-        m_1 = Util.arrayReplaceAtWithFill(row, e_1 + 1, m, {});
+        m_1 = Util.arrayReplaceAtWithFill(row, e, m, {});
         changedvars1 = varsInEqn(m_1, e);
         (m_2,changedvars2) = updateIncidenceMatrix2(dae, m_1, eqns);
       then
@@ -4001,14 +4001,13 @@ algorithm
       array<list<BackendDAE.Value>> m,mt,mt_1,mt_2;
       list<list<BackendDAE.Value>> mlst;
       list<BackendDAE.Value> row_1,vars;
-      BackendDAE.Value v_1,v;
+      BackendDAE.Value v;
     case ({},m,mt) then mt;
     case ((v :: vars),m,mt)
       equation
         mlst = arrayList(m);
         row_1 = transposeRow(mlst, v, 1);
-        v_1 = v - 1;
-        mt_1 = Util.arrayReplaceAtWithFill(row_1, v_1 + 1, mt, {});
+        mt_1 = Util.arrayReplaceAtWithFill(row_1, v, mt, {});
         mt_2 = updateTransposedMatrix(vars, m, mt_1);
       then
         mt_2;
@@ -5291,7 +5290,7 @@ public function getSolvedSystem
     output Boolean outRunMatching;
   end pastoptimiseDAEModule;
 protected
-  BackendDAE.BackendDAE dae,optdae,sode,optsode,indexed_dlow;
+  BackendDAE.BackendDAE dae,optdae,sode,sode1,optsode,indexed_dlow;
   Option<BackendDAE.IncidenceMatrix> om,omT;
   BackendDAE.IncidenceMatrix m,mT,m_1,mT_1;
   array<Integer> v1,v2,v1_1,v2_1;  
@@ -5321,8 +5320,9 @@ algorithm
   Debug.fcall("execstat",print, "*** BackendMain -> pastoptimiseDAE at time: " +& realString(clock()) +& "\n" );
   (sode,outM,outMT,outAss1,outAss2,outComps) := pastoptimiseDAE(sode,functionTree,pastOptModules,m,mT,v1,v2,comps,daeHandler);
 
+  sode1 := BackendDAECreate.findZeroCrossings(sode);
   Debug.fcall("execstat",print, "*** BackendMain -> translateDae: " +& realString(clock()) +& "\n" );
-  indexed_dlow := translateDae(sode,NONE());
+  indexed_dlow := translateDae(sode1,NONE());
   outSODE := calculateValues(inCache, inEnv, indexed_dlow);
   Debug.fcall("dumpindxdae", BackendDump.dump, outSODE); 
 end getSolvedSystem;

Compiler/BackEnd/BackendVariable.mo

@@ -2177,9 +2177,9 @@ public function daeVars
   output BackendDAE.Variables vars;
 algorithm
   vars := match (inBackendDAE)
-    local BackendDAE.Variables vars1,vars2;
-    case (BackendDAE.DAE(orderedVars = vars1, knownVars = vars2))
-      then vars1;
+    local BackendDAE.Variables vars;
+    case (BackendDAE.DAE(orderedVars = vars))
+      then vars;
   end match;
 end daeVars;
 
@@ -2188,9 +2188,9 @@ public function daeKnVars
   output BackendDAE.Variables vars;
 algorithm
   vars := match (inBackendDAE)
-    local BackendDAE.Variables vars1,vars2;
-    case (BackendDAE.DAE(orderedVars = vars1, knownVars = vars2))
-      then vars2;
+    local BackendDAE.Variables vars;
+    case (BackendDAE.DAE(knownVars = vars))
+      then vars;
   end match;
 end daeKnVars;
 

Compiler/Script/CevalScript.mo

@@ -68,18 +68,15 @@ protected import BackendDAEOptimize;
 protected import BackendDAETransform;
 protected import BackendEquation;
 protected import BackendVariable;
-protected import ConnectionGraph;
 protected import ClassInf;
 protected import ClassLoader;
-protected import Connect;
 protected import DAEQuery;
 protected import DAEUtil;
 protected import DAEDump;
 protected import Debug;
 protected import Dump;
 protected import Error;
 protected import Expression;
-protected import ExpressionDump;
 protected import Inst;
 protected import InnerOuter;
 protected import Lookup;
@@ -100,7 +97,6 @@ protected import Settings;
 protected import SimulationResults;
 protected import Tpl;
 protected import Types;
-protected import UnitAbsyn;
 protected import Unparsing;
 protected import Util;
 protected import ValuesUtil;
@@ -1775,6 +1771,7 @@ algorithm
         elimLevel = RTOpts.eliminationLevel();
         RTOpts.setEliminationLevel(0); // No variable eliminiation
         dlow = BackendDAECreate.lower(dae, Env.getFunctionTree(cache), false);
+        dlow = BackendDAECreate.findZeroCrossings(dlow);
         RTOpts.setEliminationLevel(elimLevel); // Reset elimination level
         flatModelicaStr = DAEDump.dumpStr(dae,Env.getFunctionTree(cache));
         flatModelicaStr = stringAppend("OldEqStr={'", flatModelicaStr);
@@ -3137,6 +3134,7 @@ algorithm
         dlow = BackendDAECreate.lower(dae, funcs, true); //Verificare cosa fa
         (dlow_1,_,_) = BackendDAEUtil.preOptimiseBackendDAE(dlow,funcs,
             {"removeSimpleEquations","removeParameterEqns","expandDerOperator"},NONE(),NONE());
+        dlow_1 = BackendDAECreate.findZeroCrossings(dlow_1);
         xml_filename = stringAppendList({filenameprefix,".xml"});
         funcelems = DAEUtil.getFunctionList(funcs);
         Print.clearBuf();
@@ -3162,7 +3160,8 @@ algorithm
         dlow = BackendDAECreate.lower(dae, funcs, true); //Verificare cosa fa
         (dlow_1,om,omT) = BackendDAEUtil.preOptimiseBackendDAE(dlow,funcs,
             {"removeSimpleEquations","removeParameterEqns","expandDerOperator"},NONE(),NONE());
-        (dlow_1,_,_,_,_,_) = BackendDAEUtil.transformDAE(dlow_1,funcs,BackendDAETransform.dummyDerivative,om,omT);    
+        (dlow_1,_,_,_,_,_) = BackendDAEUtil.transformDAE(dlow_1,funcs,BackendDAETransform.dummyDerivative,om,omT);
+        dlow_1 = BackendDAECreate.findZeroCrossings(dlow_1);    
         xml_filename = stringAppendList({filenameprefix,".xml"});
         funcelems = DAEUtil.getFunctionList(Env.getFunctionTree(cache));
         Print.clearBuf();