Change DAE.FunctionTree to the new AvlTree

Compiler/BackEnd/BackendDAECreate.mo

@@ -3233,14 +3233,14 @@ author:Waurich TUD 2014-10"
 algorithm
   fTreeOut := matchcontinue(fTreeIn)
     local
-      list<tuple<DAE.AvlKey,DAE.AvlValue>> funcLst;
+      list<tuple<DAE.AvlTreePathFunction.Key,DAE.AvlTreePathFunction.Value>> funcLst;
       DAE.FunctionTree funcs;
   case(_)
     equation
       true = stringEq(Flags.getConfigString(Flags.SIMCODE_TARGET),"Cpp");
-      funcLst = DAEUtil.avlTreeToList(fTreeIn);
+      funcLst = DAE.AvlTreePathFunction.toList(fTreeIn);
       funcLst = List.map(funcLst,renameFunctionParameter1);
-      funcs = DAEUtil.avlTreeAddLst(funcLst,DAEUtil.avlTreeNew());
+      funcs = DAE.AvlTreePathFunction.addList(DAE.AvlTreePathFunction.new(), funcLst);
     then funcs;
   else
     then fTreeIn;
@@ -3249,16 +3249,16 @@ end renameFunctionParameter;
 
 protected function renameFunctionParameter1"
 author:Waurich TUD 2014-10"
-  input tuple<DAE.AvlKey,DAE.AvlValue> funcIn;
-  output tuple<DAE.AvlKey,DAE.AvlValue> funcOut;
+  input tuple<DAE.AvlTreePathFunction.Key,DAE.AvlTreePathFunction.Value> funcIn;
+  output tuple<DAE.AvlTreePathFunction.Key,DAE.AvlTreePathFunction.Value> funcOut;
 algorithm
   funcOut := matchcontinue(funcIn)
     local
       Boolean pPref;
       Boolean isImpure;
       String pathName;
       Absyn.Path path;
-      DAE.AvlKey key;
+      DAE.AvlTreePathFunction.Key key;
       DAE.ElementSource source;
       DAE.Function func;
       DAE.InlineType iType;

Compiler/BackEnd/BackendDAEOptimize.mo

@@ -1425,7 +1425,7 @@ protected
   list<DAE.Function> funcelems;
 algorithm
   funcelems := DAEUtil.getFunctionList(inFunctions);
-  outFunctions := List.fold(funcelems,copyRecordConstructorAndExternalObjConstructorDestructorFold,DAE.emptyFuncTree);
+  outFunctions := List.fold(funcelems,copyRecordConstructorAndExternalObjConstructorDestructorFold,DAE.AvlTreePathFunction.Tree.EMPTY());
 end copyRecordConstructorAndExternalObjConstructorDestructor;
 
 protected function copyRecordConstructorAndExternalObjConstructorDestructorFold
@@ -1442,7 +1442,7 @@ algorithm
     // copy record constructors
     case (f as DAE.RECORD_CONSTRUCTOR(path=path),funcs)
       equation
-         funcs1 = DAEUtil.avlTreeAdd(funcs, path, SOME(f));
+         funcs1 = DAE.AvlTreePathFunction.add(funcs, path, SOME(f));
        then
         funcs1;
     // copy external objects constructors/destructors
@@ -1451,7 +1451,7 @@ algorithm
          true = boolOr(
                   stringEq(Absyn.pathLastIdent(path), "constructor"),
                   stringEq(Absyn.pathLastIdent(path), "destructor"));
-         funcs1 = DAEUtil.avlTreeAdd(funcs, path, SOME(f));
+         funcs1 = DAE.AvlTreePathFunction.add(funcs, path, SOME(f));
        then
         funcs1;
     case (_,funcs) then funcs;
@@ -1475,7 +1475,7 @@ algorithm
           bdae = BackendDAEUtil.setFunctionTree(bdae, inFunctions);
           BackendDAE.DAE(shared = BackendDAE.SHARED(functionTree = usedfuncs)) =
             removeUnusedFunctions(bdae);
-          outUsedFunctions = DAEUtil.joinAvlTrees(outUsedFunctions, usedfuncs);
+          outUsedFunctions = DAE.AvlTreePathFunction.join(outUsedFunctions, usedfuncs);
         then
           ();
 
@@ -1542,12 +1542,12 @@ protected
   list<DAE.Element> body;
 algorithm
   try // Check if the function has already been added.
-    _ := DAEUtil.avlTreeGet(inUsedFunctions, inPath);
+    _ := DAE.AvlTreePathFunction.get(inUsedFunctions, inPath);
   else // Otherwise, try to add it.
     (f, body) := getFunctionAndBody(inPath, inFunctions);
 
     if isSome(f) then
-      outUsedFunctions := DAEUtil.avlTreeAdd(outUsedFunctions, inPath, f);
+      outUsedFunctions := DAE.AvlTreePathFunction.add(outUsedFunctions, inPath, f);
       (_, outUsedFunctions) := DAEUtil.traverseDAE2(body,
         function checkUnusedFunctions(inFunctions = inFunctions), outUsedFunctions);
     end if;
@@ -1564,7 +1564,7 @@ protected
   DAE.Function fn;
 algorithm
   try
-    outFn as SOME(fn) := DAEUtil.avlTreeGet(fns, inPath);
+    outFn as SOME(fn) := DAE.AvlTreePathFunction.get(fns, inPath);
     outFnBody := DAEUtil.getFunctionElements(fn);
   else
     outFn := NONE();

Compiler/BackEnd/BackendDAEUtil.mo

@@ -8260,10 +8260,10 @@ public function createEmptyShared
 protected
   BackendDAE.Variables emptyVars = BackendVariable.emptyVars();
   BackendDAE.EquationArray emptyEqs = BackendEquation.emptyEqns();
-  DAE.FunctionTree functions = DAEUtil.avlTreeNew();
+  DAE.FunctionTree functions = DAE.AvlTreePathFunction.new();
 algorithm
   shared := BackendDAE.SHARED( emptyVars, emptyVars, emptyVars, emptyEqs, emptyEqs, {}, {}, cache, graph,
-                               DAEUtil.avlTreeNew(), emptyEventInfo(), {}, backendDAEType, {}, ei,
+                               DAE.AvlTreePathFunction.new(), emptyEventInfo(), {}, backendDAEType, {}, ei,
                                emptyPartitionsInfo() );
 end createEmptyShared;
 
@@ -8795,7 +8795,7 @@ algorithm
       DAE.Function func;
     case (DAE.CALL(path=path),_)
       equation
-        SOME(func) = DAEUtil.avlTreeGet(funcsIn,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(funcsIn,path);
          then listEmpty(DAEUtil.getFunctionElements(func));
     else true;
   end matchcontinue;

Compiler/BackEnd/Differentiate.mo

@@ -176,7 +176,7 @@ algorithm
       local
         DAE.FunctionTree fun_;
       case SOME(fun_) then fun_;
-      else DAE.emptyFuncTree;
+      else DAE.AvlTreePathFunction.Tree.EMPTY();
     end match;
 
     if Flags.isSet(Flags.DEBUG_DIFFERENTIATION) then
@@ -2088,7 +2088,7 @@ algorithm
         //print("Search for function mapper\n");
         (mapper, tp) = getFunctionMapper(path, inFunctionTree);
         (dpath, blst) = differentiateFunction1(path,mapper, tp, expl, (inDiffwrtCref, inInputData, inDiffType, inFunctionTree));
-        SOME(DAE.FUNCTION(type_=dtp,inlineType=dinl)) = DAEUtil.avlTreeGet(inFunctionTree, dpath);
+        SOME(DAE.FUNCTION(type_=dtp,inlineType=dinl)) = DAE.AvlTreePathFunction.get(inFunctionTree, dpath);
         // check if derivativ function has all expected inputs
         (true,_) = checkDerivativeFunctionInputs(blst, tp, dtp);
         (expl1,_) = List.splitOnBoolList(expl, blst);
@@ -2103,7 +2103,7 @@ algorithm
         //print("Search for function mapper2\n");
         (mapper, tp) = getFunctionMapper(path, inFunctionTree);
         (dpath, blst) = differentiateFunction1(path, mapper, tp, expl, (inDiffwrtCref, inInputData, inDiffType, inFunctionTree));
-        SOME(DAE.FUNCTION(type_ = dtp)) = DAEUtil.avlTreeGet(inFunctionTree, dpath);
+        SOME(DAE.FUNCTION(type_ = dtp)) = DAE.AvlTreePathFunction.get(inFunctionTree, dpath);
         // check if derivativ function has all expected inputs
         (false, tlst) = checkDerivativeFunctionInputs(blst, tp, dtp);
         // add Warning
@@ -2234,7 +2234,7 @@ algorithm
         //print("Search for function mapper\n");
         (mapper, tp) = getFunctionMapper(path, inFunctionTree);
         (dpath, blst) = differentiateFunction1(path,mapper, tp, expl, (inDiffwrtCref, inInputData, inDiffType, inFunctionTree));
-        SOME(DAE.FUNCTION(type_=dtp,inlineType=dinl)) = DAEUtil.avlTreeGet(inFunctionTree, dpath);
+        SOME(DAE.FUNCTION(type_=dtp,inlineType=dinl)) = DAE.AvlTreePathFunction.get(inFunctionTree, dpath);
         // check if derivativ function has all expected inputs
         (true,_) = checkDerivativeFunctionInputs(blst, tp, dtp);
         (expl1,_) = List.splitOnBoolList(expl, blst);
@@ -2259,7 +2259,7 @@ algorithm
         //print("Search for function mapper2\n");
         (mapper, tp) = getFunctionMapper(path, inFunctionTree);
         (dpath, blst) = differentiateFunction1(path, mapper, tp, expl, (inDiffwrtCref, inInputData, inDiffType, inFunctionTree));
-        SOME(DAE.FUNCTION(type_=dtp)) = DAEUtil.avlTreeGet(inFunctionTree, dpath);
+        SOME(DAE.FUNCTION(type_=dtp)) = DAE.AvlTreePathFunction.get(inFunctionTree, dpath);
         // check if derivativ function has all expected inputs
         (false, tlst) = checkDerivativeFunctionInputs(blst, tp, dtp);
         // add Warning
@@ -2280,7 +2280,7 @@ algorithm
         failure(BackendDAE.DIFF_FULL_JACOBIAN() = inDiffType);
 
         // get algorithm of the function
-        SOME(func) = DAEUtil.avlTreeGet(inFunctionTree,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(inFunctionTree,path);
 
         // differentiate function
         (dfunc, functions, blst) = differentiatePartialFunction(func, inDiffwrtCref, NONE(), inInputData, inDiffType, inFunctionTree, maxIter, expStack);
@@ -2297,7 +2297,7 @@ algorithm
         functions = DAEUtil.addDaeFunction({dfunc}, functions);
         // add differentiated function as function mapper
         func = DAEUtil.addFunctionDefinition(func, DAE.FUNCTION_DER_MAPPER(path, dpath, 1, {}, NONE(), {}));
-        functions = DAEUtil.avlTreeAdd(functions, path, SOME(func));
+        functions = DAE.AvlTreePathFunction.add(functions, path, SOME(func));
 
         // debug
         // differentiate expl
@@ -2890,7 +2890,7 @@ algorithm
       Absyn.Path name;
     case(_,_)
       equation
-          SOME(DAE.FUNCTION(functions=flst)) = DAEUtil.avlTreeGet(functions,fname);
+          SOME(DAE.FUNCTION(functions=flst)) = DAE.AvlTreePathFunction.get(functions,fname);
           DAE.FUNCTION_DER_MAPPER(lowerOrderDerivatives=lowerOrderDerivatives) = getFunctionMapper1(flst);
           name = List.last(lowerOrderDerivatives);
       then name;
@@ -2911,7 +2911,7 @@ algorithm
       String s;
     case(_,_)
       equation
-        SOME(DAE.FUNCTION(functions=flst,type_=t)) = DAEUtil.avlTreeGet(functions,fname);
+        SOME(DAE.FUNCTION(functions=flst,type_=t)) = DAE.AvlTreePathFunction.get(functions,fname);
         m = getFunctionMapper1(flst);
       then (m,t);
     case (_,_)

Compiler/BackEnd/EvaluateFunctions.mo

@@ -486,7 +486,7 @@ algorithm
         end if;
 
         // get the elements of the function and the algorithms
-        SOME(func) = DAEUtil.avlTreeGet(funcsIn,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(funcsIn,path);
         elements = DAEUtil.getFunctionElements(func);
 
         // get the input exps from the call
@@ -659,7 +659,7 @@ algorithm
         //------------------------------------------------
 
         // get the elements of the function and the algorithms
-        SOME(func) = DAEUtil.avlTreeGet(funcsIn,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(funcsIn,path);
         elements = DAEUtil.getFunctionElements(func);
         protectVars = List.filterOnTrue(elements,DAEUtil.isProtectedVar);
         algs = List.filterOnTrue(elements,DAEUtil.isAlgorithm);
@@ -892,14 +892,14 @@ algorithm
       list<DAE.Element> elements, allOutputs;
     case(DAE.CALL(path=path, expLst=lst),_)
       equation
-        SOME(func) = DAEUtil.avlTreeGet(funcs,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(funcs,path);
         elements = DAEUtil.getFunctionElements(func);
         if listEmpty(elements) then
         // its a record
           eLst = lst;
         else
        // its a call, get the scalar outputs
-        SOME(func) = DAEUtil.avlTreeGet(funcs,path);
+        SOME(func) = DAE.AvlTreePathFunction.get(funcs,path);
         elements = DAEUtil.getFunctionElements(func);
         allOutputs = List.filterOnTrue(elements,DAEUtil.isOutputVar);
         lst = List.map(List.flatten(List.map(allOutputs,getScalarsForComplexVar)),Expression.crefExp);
@@ -2638,7 +2638,7 @@ algorithm
     list<list<DAE.Statement>> stmtLstLst;
   case(DAE.STMT_ASSIGN(exp1=exp,exp=DAE.CALL(path=path)),_,_)
     equation
-      SOME(func) = DAEUtil.avlTreeGet(funcTree,path);
+      SOME(func) = DAE.AvlTreePathFunction.get(funcTree,path);
       elements = DAEUtil.getFunctionElements(func);
       algs = List.filterOnTrue(elements,DAEUtil.isAlgorithm);
       stmtLstLst = List.map(algs,DAEUtil.getStatement);

Compiler/BackEnd/SymbolicJacobian.mo

@@ -194,7 +194,7 @@ algorithm
   (symJacA , sparsePattern, sparseColoring, funcs) := createSymbolicJacobianforStates(inBackendDAE);
   shared := addBackendDAESharedJacobian(symJacA, sparsePattern, sparseColoring, shared);
   functionTree := BackendDAEUtil.getFunctions(shared);
-  functionTree := DAEUtil.joinAvlTrees(functionTree, funcs);
+  functionTree := DAE.AvlTreePathFunction.join(functionTree, funcs);
   shared := BackendDAEUtil.setSharedFunctionTree(shared, functionTree);
   outBackendDAE := BackendDAE.DAE(eqs,shared);
   System.realtimeTock(ClockIndexes.RT_CLOCK_EXECSTAT_JACOBIANS);
@@ -259,7 +259,7 @@ algorithm
     (linearModelMatrixes, funcs) = createLinearModelMatrixes(inBackendDAE, Config.acceptOptimicaGrammar(), Flags.isSet(Flags.DIS_SYMJAC_FMI20));
     shared = BackendDAEUtil.setSharedSymJacs(shared, linearModelMatrixes);
     functionTree = BackendDAEUtil.getFunctions(shared);
-    functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+    functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
     shared = BackendDAEUtil.setSharedFunctionTree(shared, functionTree);
     outBackendDAE = BackendDAE.DAE(eqs,shared);
   then outBackendDAE;
@@ -1551,7 +1551,7 @@ algorithm
 
         // Differentiate the System w.r.t inputs for matrices B
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,inputvars2,statesarr,inputvarsarr,paramvarsarr,statesarr,varlst,"B");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         backendDAE2 = BackendDAEUtil.setFunctionTree(backendDAE2, functionTree);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
@@ -1560,7 +1560,7 @@ algorithm
 
         // Differentiate the System w.r.t states for matrices C
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,states,statesarr,inputvarsarr,paramvarsarr,outputvarsarr,varlst,"C");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         backendDAE2 = BackendDAEUtil.setFunctionTree(backendDAE2, functionTree);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
@@ -1569,7 +1569,7 @@ algorithm
 
         // Differentiate the System w.r.t inputs for matrices D
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,inputvars2,statesarr,inputvarsarr,paramvarsarr,outputvarsarr,varlst,"D");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
           print("analytical Jacobians -> generated system for matrix D time: " + realString(clock()) + "\n");
@@ -1629,7 +1629,7 @@ algorithm
         optimizer_vars = BackendVariable.addVars(object, optimizer_vars);
         //BackendDump.printVariables(optimizer_vars);
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,states_inputs,statesarr,inputvarsarr,paramvarsarr,optimizer_vars,varlst,"B");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         backendDAE2 = BackendDAEUtil.setFunctionTree(backendDAE2, functionTree);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
@@ -1641,7 +1641,7 @@ algorithm
         optimizer_vars = BackendVariable.addVars(object, optimizer_vars);
         //BackendDump.printVariables(optimizer_vars);
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2,states_inputs,statesarr,inputvarsarr,paramvarsarr,optimizer_vars,varlst,"C");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         backendDAE2 = BackendDAEUtil.setFunctionTree(backendDAE2, functionTree);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
@@ -1653,7 +1653,7 @@ algorithm
         optimizer_vars = BackendVariable.listVar1(fconVarsList);
 
         (linearModelMatrix, sparsePattern, sparseColoring, funcs) = createJacobian(backendDAE2, states_inputs, statesarr, inputvarsarr, paramvarsarr, optimizer_vars, varlst, "D");
-        functionTree = DAEUtil.joinAvlTrees(functionTree, funcs);
+        functionTree = DAE.AvlTreePathFunction.join(functionTree, funcs);
         linearModelMatrices = listAppend(linearModelMatrices,{(SOME(linearModelMatrix),sparsePattern,sparseColoring)});
         if Flags.isSet(Flags.JAC_DUMP2) then
           print("analytical Jacobians -> generated system for matrix D time: " + realString(clock()) + "\n");
@@ -1875,7 +1875,7 @@ algorithm
     case(BackendDAE.DAE(shared=BackendDAE.SHARED(cache=cache, graph=graph, info=ei)), {}, _, _, _, _, _, _) equation
       jacobian = BackendDAE.DAE( {BackendDAEUtil.createEqSystem(BackendVariable.emptyVars(), BackendEquation.emptyEqns())},
                                  BackendDAEUtil.createEmptyShared(BackendDAE.JACOBIAN(), ei, cache, graph));
-    then (jacobian, DAE.emptyFuncTree);
+    then (jacobian, DAE.AvlTreePathFunction.Tree.EMPTY());
 
     case( BackendDAE.DAE( BackendDAE.EQSYSTEM(orderedVars=orderedVars, orderedEqs=orderedEqs, matching=BackendDAE.MATCHING(ass2=ass2))::{},
                          BackendDAE.SHARED(knownVars=knownVars, cache=cache,graph=graph, functionTree=functions, info=ei) ),

Compiler/FFrontEnd/FCore.mo

@@ -437,7 +437,7 @@ protected
   array<DAE.FunctionTree> instFuncs;
   StructuralParameters ht;
 algorithm
-  instFuncs := arrayCreate(1, DAE.emptyFuncTree);
+  instFuncs := arrayCreate(1, DAE.AvlTreePathFunction.Tree.EMPTY());
   ht := (HashTable.emptyHashTableSized(BaseHashTable.lowBucketSize),{});
   cache := CACHE(NONE(),instFuncs,ht,Absyn.IDENT("##UNDEFINED##"),Absyn.dummyProgram);
 end emptyCache;
@@ -534,7 +534,7 @@ algorithm
       array<DAE.FunctionTree> ef;
     case(CACHE(functions=ef),_)
       equation
-        SOME(func) = DAEUtil.avlTreeGet(arrayGet(ef,1),path);
+        SOME(func) = DAE.AvlTreePathFunction.get(arrayGet(ef,1),path);
       then func;
   end match;
 end getCachedInstFunc;
@@ -548,7 +548,7 @@ algorithm
     local
       array<DAE.FunctionTree> ef;
     case(CACHE(functions=ef),_) equation
-      _ = DAEUtil.avlTreeGet(arrayGet(ef,1),path);
+      _ = DAE.AvlTreePathFunction.get(arrayGet(ef,1),path);
     then ();
   end match;
 end checkCachedInstFuncGuard;
@@ -562,7 +562,7 @@ algorithm
     local
       array<DAE.FunctionTree> ef;
     case CACHE(functions = ef) then arrayGet(ef, 1);
-    else DAE.emptyFuncTree;
+    else DAE.AvlTreePathFunction.Tree.EMPTY();
   end match;
 end getFunctionTree;
 
@@ -590,7 +590,7 @@ algorithm
 
     case (CACHE(igraph,ef,ht,p,program),Absyn.FULLYQUALIFIED(_))
       equation
-        ef = arrayUpdate(ef,1,DAEUtil.avlTreeAdd(arrayGet(ef, 1),func,NONE()));
+        ef = arrayUpdate(ef,1,DAE.AvlTreePathFunction.add(arrayGet(ef, 1),func,NONE()));
         // print("Func quard [new]: " + Absyn.pathString(func) + "\n");
       then CACHE(igraph,ef,ht,p,program);
 

Compiler/FrontEnd/ConnectUtil.mo

@@ -2337,7 +2337,7 @@ algorithm
   // Only do this phase if we have any connection operators.
   if System.getHasStreamConnectors() or has_cardinality then
     flow_threshold := Flags.getConfigReal(Flags.FLOW_THRESHOLD);
-    DAE := DAEUtil.traverseDAE(DAE, DAE.emptyFuncTree,
+    DAE := DAEUtil.traverseDAE(DAE, DAE.AvlTreePathFunction.Tree.EMPTY(),
       function evaluateConnectionOperators2(
         hasCardinality = has_cardinality,
         setArray = setArray,