OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo - Linux GNU 11.4.0 Code Coverage Report

Directory:	./
Coverage:	low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
	Coverage	Exec / Excl / Total
Lines:	68.9%	1647 / 0 / 2391
Functions:	-%	0 / 1 / 1
Branches:	60.0%	913 / 0 / 1522
    OMCompiler/Compiler/BackEnd/BackendDAEUtil.mo
    
        Line
        Branch
        Exec
        Source
      
        /*
      
         * This file is part of OpenModelica.
      
         *
      
         * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC),
      
         * c/o Linköpings universitet, Department of Computer and Information Science,
      
         * SE-58183 Linköping, Sweden.
      
         *
      
         * All rights reserved.
      
         *
      
         * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF AGPL VERSION 3 LICENSE OR
      
         * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8.
      
         * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
      
         * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GNU AGPL
      
         * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
      
         *
      
         * The OpenModelica software and the OSMC (Open Source Modelica Consortium)
      
         * Public License (OSMC-PL) are obtained from OSMC, either from the above
      
         * address, from the URLs:
      
         * http://www.openmodelica.org or
      
         * https://github.com/OpenModelica/ or
      
         * http://www.ida.liu.se/projects/OpenModelica,
      
         * and in the OpenModelica distribution.
      
         *
      
         * GNU AGPL version 3 is obtained from:
      
         * https://www.gnu.org/licenses/licenses.html#GPL
      
         *
      
         * This program is distributed WITHOUT ANY WARRANTY; without
      
         * even the implied warranty of MERCHANTABILITY or FITNESS
      
         * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
      
         * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
      
         *
      
         * See the full OSMC Public License conditions for more details.
      
         *
      
         */
      
        encapsulated package BackendDAEUtil
      
        " file:        BackendDAEUtil.mo
      
          package:     BackendDAEUtil
      
          description: BackendDAEUtil comprised functions for BackendDAE data types.
      
          This module is a lowered form of a DAE including equations
      
          and simple equations in
      
          two separate lists. The variables are split into known variables
      
          parameters and constants, and unknown variables,
      
          states and algebraic variables.
      
          The module includes the BLT sorting algorithm which sorts the
      
          equations into blocks, and the index reduction algorithm using
      
          dummy derivatives for solving higher index problems.
      
          It also includes the tarjan algorithm to detect strong components
      
          in the BLT sorting."
      
        import Absyn;
      
        import AvlSetInt;
      
        import AvlSetPath;
      
        import BackendDAE;
      
        import BackendDAEFunc;
      
        import BackendEquation;
      
        import DAE;
      
        import FCore;
      
        import Util;
      
        protected
      
        import AdjacencyMatrix;
      
        import Algorithm;
      
        import Array;
      
        import BackendDAEOptimize;
      
        import BackendDAETransform;
      
        import BackendDump;
      
        import BackendDAEEXT;
      
        import BackendInline;
      
        import BackendVarTransform;
      
        import BackendVariable;
      
        import BaseHashTable;
      
        import BinaryTree;
      
        import Causalize;
      
        import CheckModel;
      
        import ClassInf;
      
        import CommonSubExpression;
      
        import ComponentReference;
      
        import ComponentReferenceBasics;
      
        import Config;
      
        import DAEDump;
      
        import DAEMode;
      
        import DAEUtil;
      
        import DataReconciliation;
      
        import Debug;
      
        import Differentiate;
      
        import Dump;
      
        import DumpGraphML;
      
        import DynamicOptimization;
      
        import ElementSource;
      
        import Error;
      
        import ErrorExt;
      
        import EvaluateFunctions;
      
        import EvaluateParameter;
      
        import ExecStat.execStat;
      
        import ExpandableArray;
      
        import Ceval;
      
        import Expression;
      
        import ExpressionBasics;
      
        import ExpressionDump;
      
        import ExpressionSimplify;
      
        import ExpressionSolve;
      
        import FindZeroCrossings;
      
        import Flags;
      
        import FlagsUtil;
      
        import Global;
      
        import HpcOmEqSystems;
      
        import HashSet;
      
        import HashTableExpToExp;
      
        import IndexReduction;
      
        import Initialization;
      
        import Inline;
      
        import InlineArrayEquations;
      
        import List;
      
        import Matching;
      
        import MetaModelica.Dangerous;
      
        import OnRelaxation;
      
        import RemoveSimpleEquations;
      
        import ResolveLoops;
      
        import SCode;
      
        import SCodeUtil;
      
        import Sorting;
      
        import StackOverflow;
      
        import SymbolicImplicitSolver;
      
        import SymbolicJacobian;
      
        import SynchronousFeatures;
      
        import System;
      
        import Tearing;
      
        import Types;
      
        import UnorderedSet;
      
        import Values;
      
        import XMLDump;
      
        import ZeroCrossings;
      
        public function isInitializationDAE
      
          input BackendDAE.Shared inShared;
      
          output Boolean res;
      
        algorithm
      
          res := match inShared
      
            case BackendDAE.SHARED(backendDAEType=BackendDAE.INITIALSYSTEM()) then true;
      
            else false;
      
          end match;
      
        end isInitializationDAE;
      
        public function isSimulationDAE
      
          input BackendDAE.Shared inShared;
      
          output Boolean res;
      
        algorithm
      
          res := match inShared
      
            case BackendDAE.SHARED(backendDAEType=BackendDAE.SIMULATION()) then true;
      
            else false;
      
          end match;
      
        end isSimulationDAE;
      
        public function isJacobianDAE
      
          input BackendDAE.Shared inShared;
      
          output Boolean res;
      
        algorithm
      
          res := match inShared
      
            case BackendDAE.SHARED(backendDAEType=BackendDAE.JACOBIAN()) then true;
      
            else false;
      
          end match;
      
        end isJacobianDAE;
      
        /*************************************************
      
         * checkBackendDAE and stuff
      
         ************************************************/
      
        public function checkBackendDAEWithErrorMsg "author: Frenkel TUD
      
          run checkDEALow and prints all errors"
      
          input BackendDAE.BackendDAE inBackendDAE;
      
        protected
      
          list<tuple<DAE.Exp, list<DAE.ComponentRef>>> expCrefs;
      
          list<BackendDAE.Equation> wrongEqns;
      
        algorithm
      
          1/2✓ Branch 1 taken 2170 times.
✗ Branch 2 not taken.

        2170
          if not Flags.isSet(Flags.CHECK_BACKEND_DAE) then return; end if;
      
          () := matchcontinue inBackendDAE
      
            local
      
              Integer nVars, nEqns;
      
              Boolean samesize;
      
              BackendDAE.Variables vars;
      
              BackendDAE.EquationArray orderedEqs;
      
            case BackendDAE.DAE(eqs=(BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=orderedEqs))::{}, shared=BackendDAE.SHARED()) algorithm
      
              //true = Flags.isSet(Flags.CHECK_BACKEND_DAE);
      
              //Check for correct size
      
        ✗
              nVars := BackendVariable.varsSize(vars);
      
        ✗
              nEqns := BackendEquation.equationArraySize(orderedEqs);
      
              samesize := nVars == nEqns;
      
        ✗
              if Flags.isSet(Flags.CHECK_BACKEND_DAE) then
      
        ✗
                print("No. of Equations: " + intString(nVars) + " No. of BackendDAE.Variables: " + intString(nEqns) + " Samesize: " + boolString(samesize) + "\n");
      
              end if;
      
        ✗
              (expCrefs, wrongEqns) := checkBackendDAE(inBackendDAE);
      
        ✗
              printcheckBackendDAEWithErrorMsg(expCrefs, wrongEqns);
      
            then ();
      
            else algorithm
      
        ✗
              Error.addMessage(Error.INTERNAL_ERROR, {"./Compiler/BackEnd/BackendDAEUtil.mo: function checkBackendDAEWithErrorMsg failed"});
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end checkBackendDAEWithErrorMsg;
      
        public function printcheckBackendDAEWithErrorMsg"author: Frenkel TUD
      
          helper for checkDEALowWithErrorMsg"
      
          input list<tuple<DAE.Exp,list<DAE.ComponentRef>>> inExpCrefs;
      
          input list<BackendDAE.Equation> inWrongEqns;
      
        algorithm
      
          () := match (inExpCrefs,inWrongEqns)
      
            local
      
              DAE.Exp e;
      
              list<DAE.ComponentRef> crefs;
      
              list<tuple<DAE.Exp,list<DAE.ComponentRef>>> res;
      
              list<String> strcrefs;
      
              String crefstring, expstr,scopestr;
      
              BackendDAE.Equation eqn;
      
              list<BackendDAE.Equation> wrongEqns;
      
            case ({},{})  then ();
      
            case ({},eqn::wrongEqns)
      
              algorithm
      
        ✗
                printEqnSizeError(eqn);
      
        ✗
                printcheckBackendDAEWithErrorMsg({},wrongEqns);
      
              then ();
      
            case (((e,crefs))::res,wrongEqns)
      
              algorithm
      
        ✗
                strcrefs := List.map(crefs,ComponentReference.crefStr);
      
        ✗
                crefstring := stringDelimitList(strcrefs,", ");
      
        ✗
                expstr := ExpressionBasics.printExpStr(e);
      
        ✗
                scopestr := stringAppendList({crefstring," from Expression: ",expstr});
      
        ✗
                Error.addMessage(Error.LOOKUP_VARIABLE_ERROR, {scopestr,"BackendDAE object"});
      
        ✗
                printcheckBackendDAEWithErrorMsg(res,wrongEqns);
      
              then
      
                ();
      
          end match;
      
        end printcheckBackendDAEWithErrorMsg;
      
        protected function printEqnSizeError"author: Frenkel TUD 2010-12"
      
            input BackendDAE.Equation inEqn;
      
        algorithm
      
          () := matchcontinue inEqn
      
          local
      
            BackendDAE.Equation eqn;
      
            DAE.Exp e1, e2;
      
            DAE.ComponentRef cr;
      
            DAE.Type t1,t2;
      
            String eqnstr, t1str, t2str, tstr;
      
            DAE.ElementSource source;
      
            case eqn as BackendDAE.EQUATION(exp=e1,scalar=e2,source=source)
      
              algorithm
      
        ✗
                eqnstr := BackendDump.equationString(eqn);
      
        ✗
                t1 := Expression.typeof(e1);
      
        ✗
                t2 := Expression.typeof(e2);
      
        ✗
                t1str := TypesDump.unparseTypeNoAttr(t1);
      
        ✗
                t2str := TypesDump.unparseTypeNoAttr(t2);
      
        ✗
                tstr := stringAppendList({t1str," != ", t2str});
      
        ✗
                Error.addSourceMessage(Error.EQUATION_TYPE_MISMATCH_ERROR, {eqnstr,tstr}, ElementSource.getElementSourceFileInfo(source));
      
              then ();
      
            case eqn as BackendDAE.SOLVED_EQUATION(componentRef=cr,exp=e1,source=source)
      
              algorithm
      
        ✗
                eqnstr := BackendDump.equationString(eqn);
      
        ✗
                t1 := Expression.typeof(e1);
      
        ✗
                t2 := ComponentReference.crefLastType(cr);
      
        ✗
                t1str := TypesDump.unparseTypeNoAttr(t1);
      
        ✗
                t2str := TypesDump.unparseTypeNoAttr(t2);
      
        ✗
                tstr := stringAppendList({t1str," != ", t2str});
      
        ✗
                Error.addSourceMessage(Error.EQUATION_TYPE_MISMATCH_ERROR, {eqnstr,tstr}, ElementSource.getElementSourceFileInfo(source));
      
              then ();
      
              //
      
            else ();
      
          end matchcontinue;
      
        end printEqnSizeError;
      
        public function checkBackendDAE "author: Frenkel TUD
      
          This function checks the BackendDAE object if
      
          -  all component refercences used in the expressions are
      
             part of the BackendDAE object.
      
          -  all variables that are reinit are states
      
          Returns all component references which not part of the BackendDAE object."
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          output list<tuple<DAE.Exp,list<DAE.ComponentRef>>> outExpCrefs;
      
          output list<BackendDAE.Equation> outWrongEqns;
      
        algorithm
      
          (outExpCrefs,outWrongEqns) := matchcontinue inBackendDAE
      
            local
      
              BackendDAE.EqSystem syst;
      
              BackendDAE.Shared shared;
      
              BackendDAE.Variables allvars;
      
              list<tuple<DAE.Exp,list<DAE.ComponentRef>>> expcrefs;
      
              list<BackendDAE.Equation> wrongEqns;
      
            case BackendDAE.DAE(syst::{}, shared)
      
              algorithm
      
        ✗
                allvars := BackendVariable.mergeVariables(syst.orderedVars, shared.globalKnownVars);
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsVars(syst.orderedVars, checkBackendDAEExp, (allvars, {}));
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsEqns(shared.removedEqs, checkBackendDAEExp, (allvars, expcrefs));
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsVars(shared.globalKnownVars, checkBackendDAEExp, (allvars, expcrefs));
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsEqns(syst.orderedEqs, checkBackendDAEExp, (allvars, expcrefs));
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsEqns(syst.removedEqs, checkBackendDAEExp, (allvars, expcrefs));
      
        ✗
                (_, expcrefs) := traverseBackendDAEExpsEqns(shared.initialEqs, checkBackendDAEExp, (allvars, expcrefs));
      
        ✗
                wrongEqns := BackendEquation.traverseEquationArray(syst.orderedEqs, checkEquationSize, {});
      
        ✗
                wrongEqns := BackendEquation.traverseEquationArray(shared.removedEqs, checkEquationSize, wrongEqns);
      
        ✗
                wrongEqns := BackendEquation.traverseEquationArray(syst.removedEqs, checkEquationSize, wrongEqns);
      
        ✗
                wrongEqns := BackendEquation.traverseEquationArray(shared.initialEqs, checkEquationSize, wrongEqns);
      
              then
      
                (expcrefs, wrongEqns);
      
            else
      
              algorithm
      
        ✗
                true := Flags.isSet(Flags.FAILTRACE);
      
        ✗
                Debug.trace("- BackendDAEUtil.checkBackendDAE failed\n");
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end checkBackendDAE;
      
        protected function checkBackendDAEExp
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,list<tuple<DAE.Exp,list<DAE.ComponentRef>>>> inTpl;
      
          output DAE.Exp outExp;
      
          output tuple<BackendDAE.Variables,list<tuple<DAE.Exp,list<DAE.ComponentRef>>>> outTpl;
      
        algorithm
      
          (outExp,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              DAE.Exp exp;
      
              BackendDAE.Variables vars;
      
              list<DAE.ComponentRef> crefs;
      
              list<tuple<DAE.Exp,list<DAE.ComponentRef>>> lstExpCrefs;
      
            case (exp,(vars,lstExpCrefs))
      
              algorithm
      
        ✗
                (_,(_,crefs)) := Expression.traverseExpBottomUp(exp,traversecheckBackendDAEExp,(vars,{}));
      
        ✗
               then (exp, if not listEmpty(crefs) then (vars,(exp,crefs)::lstExpCrefs) else inTpl);
      
            else (inExp,inTpl);
      
          end matchcontinue;
      
        end checkBackendDAEExp;
      
        protected function traversecheckBackendDAEExp
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,list<DAE.ComponentRef>> inTuple;
      
          output DAE.Exp outExp;
      
          output tuple<BackendDAE.Variables,list<DAE.ComponentRef>> outTuple;
      
        algorithm
      
          (outExp,outTuple) := matchcontinue (inExp,inTuple)
      
            local
      
              DAE.Exp e,e1;
      
              BackendDAE.Variables vars;
      
              DAE.ComponentRef cr;
      
              list<DAE.ComponentRef> crefs;
      
              list<DAE.Exp> expl;
      
              list<DAE.Var> varLst;
      
              list<BackendDAE.Var> backendVars;
      
              DAE.ReductionIterators riters;
      
              tuple<BackendDAE.Variables,list<DAE.ComponentRef>> tp;
      
            // special case for time, it is never part of the equation system
      
            case (e as DAE.CREF(componentRef = DAE.CREF_IDENT(ident="time")),_)
      
              then (e, inTuple);
      
            // Special Case for Records
      
            case (e as DAE.CREF(componentRef = cr,ty= DAE.T_COMPLEX(varLst=varLst,complexClassType=ClassInf.RECORD(_))),_)
      
              algorithm
      
        ✗
                expl := List.map1(varLst,Expression.generateCrefsExpFromExpVar,cr);
      
        ✗
                (_,tp) := Expression.traverseExpList(expl,traversecheckBackendDAEExp,inTuple);
      
        ✗
              then (e, tp);
      
            // Special Case for Arrays
      
            case (e as DAE.CREF(ty = DAE.T_ARRAY()),_)
      
              algorithm
      
        ✗
                (e1,true) := Expression.extendArrExp(e,false);
      
        ✗
                (_,tp) := Expression.traverseExpBottomUp(e1,traversecheckBackendDAEExp,inTuple);
      
        ✗
              then (e, tp);
      
            // case for Reductions
      
            case (e as DAE.REDUCTION(iterators = riters),(vars,crefs))
      
              algorithm
      
                // add idents to vars
      
        ✗
                backendVars := List.map(riters,makeIterVariable);
      
        ✗
                vars := BackendVariable.addVars(backendVars,vars);
      
        ✗
              then (e, (vars,crefs));
      
            // case for functionpointers
      
            case (e as DAE.CREF(ty=DAE.T_FUNCTION_REFERENCE_FUNC()),_)
      
              then (e, inTuple);
      
            case (e as DAE.CREF(componentRef = cr),(vars,_))
      
              algorithm
      
        ✗
                 BackendVariable.getVar(cr, vars);
      
              then (e, inTuple);
      
            case (e as DAE.CREF(componentRef = cr),(vars,crefs))
      
              //failed before, so no need to getVar() again
      
                 //failure((_,_) = BackendVariable.getVar(cr, vars));
      
        ✗
              then (e, (vars,cr::crefs));
      
            else (inExp,inTuple);
      
          end matchcontinue;
      
        end traversecheckBackendDAEExp;
      
        protected function makeIterVariable
      
          input DAE.ReductionIterator iter;
      
          output BackendDAE.Var backendVar;
      
        protected
      
          String name;
      
          DAE.ComponentRef cr;
      
        algorithm
      
        ✗
          name := Expression.reductionIterName(iter);
      
        ✗
          cr := ComponentReferenceBasics.makeCrefIdent(name,DAE.T_INTEGER_DEFAULT,{});
      
        ✗
          backendVar := BackendDAE.VAR(cr, BackendDAE.VARIABLE(), DAE.BIDIR(), DAE.NON_PARALLEL(), DAE.T_INTEGER_DEFAULT, NONE(), NONE(), {}, DAE.emptyElementSource, NONE(), NONE(), NONE(), NONE(), DAE.NON_CONNECTOR(), DAE.NOT_INNER_OUTER(), false, false, false);
      
        end makeIterVariable;
      
        protected function checkEquationSize"author: Frenkel TUD 2010-12
      
          - check if the left hand side and the rigth hand side have equal types."
      
          input BackendDAE.Equation inEq;
      
          input list<BackendDAE.Equation> inEqs;
      
          output BackendDAE.Equation outEq;
      
          output list<BackendDAE.Equation> outEqs;
      
        algorithm
      
          (outEq,outEqs) := matchcontinue (inEq,inEqs)
      
            local
      
              BackendDAE.Equation e;
      
              list<BackendDAE.Equation> wrongEqns,wrongEqns1;
      
              DAE.Exp e1, e2;
      
              DAE.ComponentRef cr;
      
              DAE.Type t1,t2;
      
              Boolean b;
      
            case (e as BackendDAE.EQUATION(exp=e1,scalar=e2),wrongEqns)
      
              algorithm
      
        ✗
                t1 := Expression.typeof(e1);
      
        ✗
                t2 := Expression.typeof(e2);
      
        ✗
                b := Expression.equalTypes(t1,t2);
      
        ✗
                wrongEqns1 := List.consOnTrue(not b,e,wrongEqns);
      
              then (e,wrongEqns1);
      
            case (e as BackendDAE.SOLVED_EQUATION(componentRef=cr,exp=e1),wrongEqns)
      
              algorithm
      
        ✗
                t1 := Expression.typeof(e1);
      
        ✗
                t2 := ComponentReference.crefLastType(cr);
      
        ✗
                b := Expression.equalTypes(t1,t2);
      
        ✗
                wrongEqns1 := List.consOnTrue(not b,e,wrongEqns);
      
              then (e,wrongEqns1);
      
              //
      
            else (inEq,inEqs);
      
          end matchcontinue;
      
        end checkEquationSize;
      
        public function checkAssertCondition "Succeds if condition of assert is not constant false"
      
          input DAE.Exp cond;
      
          input DAE.Exp message;
      
          input DAE.Exp level;
      
          input SourceInfo info;
      
        algorithm
      
          // Don't check assertions when checking models
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 32908 times.

        32908
          if Flags.getConfigBool(Flags.CHECK_MODEL) then return; end if;
      
          () := matchcontinue info
      
            local
      
              String messageStr;
      
            case _
      
              guard
      
                not Expression.isConstFalse(cond)
      
              then ();
      
            case _
      
              algorithm
      
          3/6✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 time.

        1
                failure(DAE.ENUM_LITERAL(index=2) := level);
      
              then ();
      
            case _
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
                true := Expression.isConstFalse(cond);
      
        1
                messageStr := ExpressionBasics.printExpStr(message);
      
        1
                Error.addSourceMessage(Error.ASSERT_CONSTANT_FALSE_ERROR,{messageStr},info);
      
        1
              then fail();
      
          end matchcontinue;
      
        end checkAssertCondition;
      
        // =============================================================================
      
        // Util function at Backend using for lowering and other stuff
      
        //
      
        // =============================================================================
      
        public function copyBackendDAE "author: Frenkel TUD, wbraun
      
          Copy the dae to avoid changes in vectors."
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.BackendDAE outDAE;
      
        algorithm
      
        3106
          outDAE := mapEqSystem(inDAE, copyEqSystemTraverser);
      
        3106
          outDAE.shared := copyBackendDAEShared(outDAE.shared);
      
        end copyBackendDAE;
      
        public function copyEqSystemTraverser
      
          input BackendDAE.EqSystem inSystem;
      
          input BackendDAE.Shared inShared;
      
          output BackendDAE.EqSystem outSystem;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
        9259
          outSystem := copyEqSystem(inSystem);
      
          outShared := inShared;
      
        end copyEqSystemTraverser;
      
        public function copyEqSystem
      
          input BackendDAE.EqSystem inSystem;
      
          output BackendDAE.EqSystem outSystem;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqns, removedEqs;
      
          Option<BackendDAE.AdjacencyMatrix> m, mt;
      
          BackendDAE.Matching matching;
      
        algorithm
      
        29632
          vars := BackendVariable.copyVariables(inSystem.orderedVars);
      
        29632
          eqns := BackendEquation.copyEquationArray(inSystem.orderedEqs);
      
        29632
          removedEqs := BackendEquation.copyEquationArray(inSystem.removedEqs);
      
        29632
          m := AdjacencyMatrix.copyAdjacencyMatrix(inSystem.m);
      
        29632
          mt := AdjacencyMatrix.copyAdjacencyMatrixT(inSystem.mT);
      
        29632
          matching := copyMatching(inSystem.matching);
      
        29632
          outSystem := BackendDAE.EQSYSTEM(vars, eqns, m, mt, inSystem.mapping, matching, inSystem.stateSets, inSystem.partitionKind, removedEqs);
      
        end copyEqSystem;
      
        public function copyEqSystems
      
          input BackendDAE.EqSystems inSystems;
      
          output BackendDAE.EqSystems outSystems = {};
      
        algorithm
      
          2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 12 times.

        30
          for e in inSystems loop
      
        18
            outSystems := copyEqSystem(e) :: outSystems;
      
          end for;
      
        end copyEqSystems;
      
        public function mergeEqSystems
      
          input BackendDAE.EqSystem System1;
      
          input output BackendDAE.EqSystem System2;
      
        algorithm
      
        77
          System2.orderedEqs := BackendEquation.merge(System1.orderedEqs,System2.orderedEqs);
      
          System2.orderedVars := BackendVariable.mergeVariables(System1.orderedVars,System2.orderedVars);
      
        end mergeEqSystems;
      
        public function copyBackendDAEShared
      
        "  author: Frenkel TUD, wbraun
      
          Copy the shared part of an BackendDAE to avoid changes in
      
          vectors."
      
          input BackendDAE.Shared inShared;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared:=
      
          match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
              algorithm
      
        3106
                shared.globalKnownVars := BackendVariable.copyVariables(shared.globalKnownVars);
      
        3106
                shared.externalObjects := BackendVariable.copyVariables(shared.externalObjects);
      
        3106
                shared.initialEqs := BackendEquation.copyEquationArray(shared.initialEqs);
      
        3106
                shared.removedEqs := BackendEquation.copyEquationArray(shared.removedEqs);
      
              then
      
                shared;
      
          end match;
      
        end copyBackendDAEShared;
      
        public function copyMatching
      
          input BackendDAE.Matching inMatching;
      
          output BackendDAE.Matching outMatching;
      
        algorithm
      
          outMatching := match inMatching
      
            local
      
              array<Integer> ass1, cass1, ass2, cass2;
      
              BackendDAE.StrongComponents comps;
      
            case BackendDAE.NO_MATCHING() then BackendDAE.NO_MATCHING();
      
            case BackendDAE.MATCHING(ass1=ass1,ass2=ass2,comps=comps)
      
              algorithm
      
        9297
                cass1 := arrayCopy(ass1);
      
        9297
                cass2 := arrayCopy(ass2);
      
        9297
              then BackendDAE.MATCHING(cass1,cass2,comps);
      
          end match;
      
        end copyMatching;
      
        public function getCompsOfMatching "author: mwalther
      
          Get all strong connected components of the given matching. If the matching
      
          has the concrete type NO_MATCHING, the returned list is empty."
      
          input BackendDAE.Matching inMatching;
      
          output BackendDAE.StrongComponents outComps;
      
        algorithm
      
          outComps := match inMatching
      
            local
      
              BackendDAE.StrongComponents comps;
      
            case BackendDAE.MATCHING(comps=comps)
      
              then comps;
      
            else
      
              then {};
      
          end match;
      
        end getCompsOfMatching;
      
        public function addVarsToEqSystem
      
          input BackendDAE.EqSystem syst;
      
          input list<BackendDAE.Var> varlst;
      
          output BackendDAE.EqSystem osyst;
      
        protected
      
          BackendDAE.Variables vars;
      
        algorithm
      
        4718
          BackendDAE.EQSYSTEM(orderedVars=vars) := syst;
      
        4718
          osyst := setEqSystVars(syst, BackendVariable.addVars(varlst, vars));
      
        end addVarsToEqSystem;
      
        public function numberOfZeroCrossings "author: lochel"
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          output Integer outNumZeroCrossings "number of ordinary zero crossings" ;
      
          output Integer outNumTimeEvents    "number of zero crossings that are time events" ;
      
          output Integer outNumRelations;
      
          output Integer outNumMathEventFunctions;
      
        protected
      
          BackendDAE.EventInfo eventInfo = inBackendDAE.shared.eventInfo;
      
        algorithm
      
        1069
          outNumZeroCrossings := ZeroCrossings.length(eventInfo.zeroCrossings);
      
        1069
          outNumTimeEvents := listLength(eventInfo.timeEvents);
      
        1069
          outNumRelations := ZeroCrossings.count(eventInfo.relations);
      
          1/2✓ Branch 0 taken 1069 times.
✗ Branch 1 not taken.

        1069
          outNumMathEventFunctions := eventInfo.numberMathEvents;
      
        end numberOfZeroCrossings;
      
        public function numberOfDiscreteVars "author: lochel"
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          output Integer outNumDiscreteReal;
      
        algorithm
      
        ✗
          outNumDiscreteReal := countDiscreteVars(inBackendDAE);
      
        end numberOfDiscreteVars;
      
        protected function countDiscreteVars "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          output Integer outNumDiscreteVars;
      
        protected
      
          BackendDAE.Variables globalKnownVars, alias;
      
        algorithm
      
        ✗
          BackendDAE.SHARED(globalKnownVars=globalKnownVars, aliasVars=alias) := inDAE.shared;
      
        ✗
          outNumDiscreteVars := countDiscreteVars1(inDAE.eqs);
      
        ✗
          outNumDiscreteVars := BackendVariable.traverseBackendDAEVars(globalKnownVars, countDiscreteVars3, outNumDiscreteVars);
      
        ✗
          outNumDiscreteVars := BackendVariable.traverseBackendDAEVars(alias, countDiscreteVars3, outNumDiscreteVars);
      
        end countDiscreteVars;
      
        protected function countDiscreteVars1 "author: lochel"
      
          input BackendDAE.EqSystems inEqSystems;
      
          output Integer outNumDiscreteVars;
      
        algorithm
      
          outNumDiscreteVars := 0;
      
        ✗
          outNumDiscreteVars := List.fold(inEqSystems, countDiscreteVars2, outNumDiscreteVars);
      
        end countDiscreteVars1;
      
        protected function countDiscreteVars2 "author: lochel"
      
          input BackendDAE.EqSystem inEqSystem;
      
          input Integer inNumDiscreteVars;
      
          output Integer outNumDiscreteVars;
      
        protected
      
          BackendDAE.Variables vars;
      
        algorithm
      
        ✗
          BackendDAE.EQSYSTEM(orderedVars=vars) := inEqSystem;
      
        ✗
          outNumDiscreteVars := BackendVariable.traverseBackendDAEVars(vars, countDiscreteVars3, inNumDiscreteVars);
      
        end countDiscreteVars2;
      
        protected function countDiscreteVars3 "author: lochel"
      
          input BackendDAE.Var var;
      
          input Integer nDiscreteVars;
      
          output BackendDAE.Var outVar;
      
          output Integer outCount;
      
        algorithm
      
          (outVar,outCount) := match var
      
            // discrete
      
            case BackendDAE.VAR(varKind=BackendDAE.DISCRETE(), varType=DAE.T_REAL())
      
        ✗
              then (var, nDiscreteVars+1);
      
            else (var,nDiscreteVars);
      
          end match;
      
        end countDiscreteVars3;
      
        public function replaceCrefsWithValues
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables, DAE.ComponentRef> inTuple;
      
          output DAE.Exp outExp;
      
          output tuple<BackendDAE.Variables, DAE.ComponentRef> outTuple;
      
        algorithm
      
          (outExp,outTuple) := matchcontinue (inExp,inTuple)
      
            local
      
              DAE.Exp e;
      
              BackendDAE.Variables vars;
      
              DAE.ComponentRef cr, cr_orign;
      
            case (DAE.CREF(cr, _), (vars, cr_orign))
      
              guard
      
                not ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr_orign)
      
              algorithm
      
          3/8✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✓ Branch 5 taken 24 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.

        29
                ({BackendDAE.VAR(bindExp = SOME(e))}, _) := BackendVariable.getVar(cr, vars);
      
        ✗
                (e, _) := Expression.traverseExpBottomUp(e, replaceCrefsWithValues, (vars, cr_orign));
      
        ✗
              then (e, (vars,cr_orign));
      
            else (inExp,inTuple);
      
          end matchcontinue;
      
        end replaceCrefsWithValues;
      
        public function makeExpType
      
        "Transforms a BackendDAE.Type to DAE.Type"
      
          input BackendDAE.Type inType;
      
          output DAE.Type outType;
      
        algorithm
      
          outType := inType;
      
        end makeExpType;
      
        public function hasExpContinuousParts
      
        "Returns true if expression has contiuous parts,
      
         and false if the expression is completely discrete.
      
         Used to detect if an expression is a ZeroCrossing."
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.Variables inKnvars;
      
          output Boolean outBoolean;
      
        algorithm
      
        12790
          (_,(_, _, outBoolean)) := Expression.traverseExpTopDown(inExp, traversingContinuousExpFinder, (inVariables, inKnvars, false));
      
        end hasExpContinuousParts;
      
        protected function traversingContinuousExpFinder "Helper for isDiscreteExp"
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,BackendDAE.Variables,Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables,BackendDAE.Variables,Boolean> outTpl;
      
        algorithm
      
          (outExp, cont, outTpl) := matchcontinue (inExp, inTpl)
      
            local
      
              BackendDAE.Variables vars, globalKnownVars;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Var backendVar;
      
              Absyn.Ident name;
      
            case (DAE.CREF(componentRef=cr), (vars, globalKnownVars, _)) algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4569 times.

        8221
              ((backendVar::_), _) := BackendVariable.getVar(cr, vars);
      
          2/2✓ Branch 1 taken 2217 times.
✓ Branch 2 taken 2352 times.

        4569
              false := BackendVariable.isVarDiscrete(backendVar);
      
        2352
            then (inExp, false, (vars, globalKnownVars, true));
      
            // builtin variable time is not discrete
      
            case (DAE.CREF(componentRef=DAE.CREF_IDENT(ident="time")), (vars, globalKnownVars, _))
      
        1356
            then (inExp, false, (vars, globalKnownVars, true));
      
            // Known variables that are input are continuous
      
            case (DAE.CREF(componentRef=cr), (vars, globalKnownVars, _)) algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1979 times.

        4513
              (backendVar::_, _) := BackendVariable.getVar(cr, globalKnownVars);
      
          1/2✓ Branch 1 taken 1979 times.
✗ Branch 2 not taken.

        1979
              true := BackendVariable.isInput(backendVar);
      
        ✗
            then (inExp, false, (vars, globalKnownVars, true));
      
            case (DAE.CALL(path=Absyn.IDENT(name=name)), _)
      
              guard stringEq("pre", name) or
      
                    stringEq("change", name) or
      
                    stringEq("ceil", name) or
      
                    stringEq("floor", name)
      
            then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="noEvent")), (vars, globalKnownVars, _))
      
        6850
            then (inExp, false, (vars, globalKnownVars, false));
      
            else (inExp, true, inTpl);
      
          end matchcontinue;
      
        end traversingContinuousExpFinder;
      
        public function statesAndVarsExp
      
        "This function investigates an expression and returns as subexpressions
      
          that are variable names or derivatives of state names or states
      
          inputs:  (DAE.Exp, BackendDAE.Variables)
      
          outputs: DAE.Exp list"
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVariables;
      
          output list<DAE.Exp> exps;
      
        algorithm
      
        ✗
          (_,(_,exps)) := Expression.traverseExpTopDown(inExp, traversingstatesAndVarsExpFinder, (inVariables,{}));
      
        end statesAndVarsExp;
      
        public function traversingstatesAndVarsExpFinder "
      
        Author: Frenkel TUD 2010-10
      
        Helper for statesAndVarsExp"
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,list<DAE.Exp>> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables,list<DAE.Exp>> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.Exp> expl,res,creexps;
      
              DAE.Exp e,e1;
      
              list<DAE.Var> varLst;
      
              BackendDAE.Variables vars;
      
            // Special Case for Records
      
            case ((e as DAE.CREF(componentRef = cr,ty= DAE.T_COMPLEX(varLst=varLst,complexClassType=ClassInf.RECORD(_)))),(vars,_))
      
              algorithm
      
        ✗
                creexps := List.map1(varLst,Expression.generateCrefsExpFromExpVar,cr);
      
        ✗
                (_,(_,res)) := Expression.traverseExpListTopDown(creexps, traversingstatesAndVarsExpFinder, inTpl);
      
        ✗
              then (e,true,(vars,res));
      
            // Special Case for unextended arrays
      
            case ((e as DAE.CREF(ty = DAE.T_ARRAY())),(vars,_))
      
              algorithm
      
        ✗
                (e1,true) := Expression.extendArrExp(e,false);
      
        ✗
                (_,(_,res)) := Expression.traverseExpTopDown(e1, traversingstatesAndVarsExpFinder, inTpl);
      
        ✗
              then (e,true,(vars,res));
      
            // Special Case for time variable
      
            //case (((e as DAE.CREF(componentRef = DAE.CREF_IDENT(ident="time"))),(vars,expl)))
      
            //  then ((e,false,(vars,e::expl)));
      
            case ((e as DAE.CREF(componentRef = cr)),(vars,expl))
      
              algorithm
      
        ✗
                BackendVariable.getVar(cr, vars);
      
        ✗
              then (e,false,(vars,e::expl));
      
            case ((e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)})),(vars,expl))
      
              algorithm
      
        ✗
                ((BackendDAE.VAR(varKind = BackendDAE.STATE())::_),_) := BackendVariable.getVar(cr, vars);
      
        ✗
              then (e,false,(vars,e::expl));
      
            // is this case right?
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,_))
      
              algorithm
      
        ✗
                BackendVariable.getVar(cr, vars);
      
              then (e,false,inTpl);
      
            else (inExp,true,inTpl);
      
          end matchcontinue;
      
        end traversingstatesAndVarsExpFinder;
      
        public function isLoopDependent
      
          "Checks if an expression is a variable that depends on a loop iterator,
      
          ie. for i loop
      
                V[i] = ...  // V depends on i
      
              end for;
      
          Used by lowerStatementInputsOutputs in STMT_FOR case."
      
          input DAE.Exp varExp;
      
          input DAE.Exp iteratorExp;
      
          output Boolean isDependent;
      
        algorithm
      
          isDependent := matchcontinue varExp
      
            local
      
              list<DAE.Exp> subscript_exprs;
      
              list<DAE.Subscript> subscripts;
      
              DAE.ComponentRef cr;
      
            case DAE.CREF(componentRef = cr)
      
              algorithm
      
        ✗
                subscripts := ComponentReferenceBasics.crefSubs(cr);
      
        ✗
                subscript_exprs := List.map(subscripts, ExpressionBasics.subscriptIndexExp);
      
        ✗
                true := isLoopDependentHelper(subscript_exprs, iteratorExp);
      
              then true;
      
            case DAE.ASUB(sub = subscripts)
      
              algorithm
      
        ✗
                subscript_exprs := List.map(subscripts, Expression.getSubscriptExp);
      
        ✗
            then isLoopDependentHelper(subscript_exprs, iteratorExp);
      
            else false;
      
          end matchcontinue;
      
        end isLoopDependent;
      
        protected function isLoopDependentHelper
      
          "Helper for isLoopDependent.
      
          Checks if a list of subscripts contains a certain iterator expression."
      
          input list<DAE.Exp> subscripts;
      
          input DAE.Exp iteratorExp;
      
          output Boolean isDependent = false;
      
        algorithm
      
        ✗
          for subscript in subscripts loop
      
            try
      
        ✗
              if Expression.expContains(subscript, iteratorExp) then
      
                isDependent := true;
      
        ✗
                return;
      
              end if;
      
            else
      
              // go on with iteration
      
            end try;
      
          end for;
      
        end isLoopDependentHelper;
      
        public function devectorizeArrayVar
      
          input DAE.Exp arrayVar;
      
          output DAE.Exp newArrayVar;
      
        algorithm
      
          newArrayVar := matchcontinue arrayVar
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.Subscript> subs;
      
              DAE.Exp e;
      
            case DAE.ASUB(exp = DAE.ARRAY(array = (DAE.CREF(componentRef = cr)::_)), sub = subs)
      
              algorithm
      
        ✗
                cr := ComponentReferenceBasics.crefStripLastSubs(cr);
      
        ✗
                e := Expression.crefExp(cr);
      
        ✗
              then
      
                // adrpo: TODO! FIXME! check if this is TYPE correct!
      
                //        shouldn't we change the type using the subs?
      
                Expression.makeASUB(e, list(Expression.getSubscriptExp(s) for s in subs));
      
            case DAE.ASUB(exp = DAE.MATRIX(matrix = (((DAE.CREF(componentRef = cr))::_)::_)), sub = subs)
      
              algorithm
      
        ✗
                cr := ComponentReferenceBasics.crefStripLastSubs(cr);
      
        ✗
                e := Expression.crefExp(cr);
      
        ✗
              then
      
                // adrpo: TODO! FIXME! check if this is TYPE correct!
      
                //        shouldn't we change the type using the subs?
      
                Expression.makeASUB(e, list(Expression.getSubscriptExp(s) for s in subs));
      
            case _ then arrayVar;
      
          end matchcontinue;
      
        end devectorizeArrayVar;
      
        public function explodeArrayVars
      
          "Explodes an array variable into its elements. Takes a variable that is a CREF
      
          or ASUB, the name of the iterator variable and a range expression that the
      
          iterator iterates over."
      
          input DAE.Exp arrayVar;
      
          input DAE.Exp iteratorExp;
      
          input DAE.Exp rangeExpr;
      
          input BackendDAE.Variables vars;
      
          output list<DAE.Exp> arrayElements;
      
        algorithm
      
          arrayElements := matchcontinue arrayVar
      
            local
      
              list<DAE.Exp> clonedElements, newElements;
      
              list<DAE.Exp> indices;
      
              DAE.ComponentRef cref;
      
              list<DAE.Exp> varExprs;
      
              DAE.Exp daeExp;
      
              list<BackendDAE.Var> bvars;
      
            case DAE.CREF()
      
              algorithm
      
        ✗
                indices := rangeExprs(rangeExpr);
      
        ✗
                clonedElements := List.fill(arrayVar, listLength(indices));
      
        ✗
                newElements := generateArrayElements(clonedElements, indices, iteratorExp);
      
              then newElements;
      
            case DAE.ASUB(exp = DAE.CREF())
      
              algorithm
      
                // If the range is constant, then we can use it to generate only those
      
                // array elements that are actually used.
      
        ✗
                indices := rangeExprs(rangeExpr);
      
        ✗
                clonedElements := List.fill(arrayVar, listLength(indices));
      
        ✗
                newElements := generateArrayElements(clonedElements, indices, iteratorExp);
      
              then newElements;
      
            case DAE.CREF(componentRef = cref)
      
              algorithm
      
        ✗
                (bvars, _) := BackendVariable.getVar(cref, vars);
      
        ✗
                varExprs := List.map(bvars, BackendVariable.varExp);
      
                //varCrefs = List.map(bvars, BackendVariable.varCref);
      
                //varExprs = List.map(varCrefs, Expression.crefExp);
      
              then varExprs;
      
            case DAE.ASUB(exp = DAE.CREF(componentRef = cref))
      
              algorithm
      
                // If the range is not constant, then we just extract all array elements
      
                // of the array.
      
        ✗
                (bvars, _) := BackendVariable.getVar(cref, vars);
      
        ✗
                varExprs := List.map(bvars, BackendVariable.varExp);
      
                //varCrefs = List.map(bvars, BackendVariable.varCref);
      
                //varExprs = List.map(varCrefs, Expression.crefExp);
      
              then varExprs;
      
            case DAE.ASUB(exp = daeExp)
      
              algorithm
      
        ✗
                varExprs := Expression.flattenArrayExpToList(daeExp);
      
              then
      
                varExprs;
      
          end matchcontinue;
      
        end explodeArrayVars;
      
        protected function rangeExprs
      
          "Tries to convert a range to a list of integer expressions. Returns a list of
      
          integer expressions if possible, or fails. Used by explodeArrayVars."
      
          input DAE.Exp inRange;
      
          output list<DAE.Exp> outValues;
      
        algorithm
      
          outValues := match inRange
      
            local
      
              list<DAE.Exp> arrayElements;
      
            case DAE.ARRAY(array = arrayElements) then arrayElements;
      
        ✗
            case DAE.RANGE() then Expression.expandRange(inRange);
      
          end match;
      
        end rangeExprs;
      
        public function daeSize
      
        "author: Frenkel TUD
      
          Returns the size of the dae system, which correspondents to the number of variables."
      
          input BackendDAE.BackendDAE inDAE;
      
          output Integer sz;
      
        algorithm
      
          4/4✓ Branch 0 taken 122787 times.
✓ Branch 1 taken 10487 times.
✓ Branch 2 taken 122787 times.
✓ Branch 3 taken 10487 times.

        133274
          sz := sum(systemSize(s) for s in inDAE.eqs);
      
        end daeSize;
      
        public function systemSize
      
          "Returns the size of the dae system, the size of the equations in an BackendDAE.EquationArray,
      
          which not corresponds to the number of equations in a system."
      
          input BackendDAE.EqSystem inEqSystem;
      
          output Integer outSize = BackendEquation.equationArraySize(inEqSystem.orderedEqs);
      
        end systemSize;
      
        public function maxSizeOfEqSystems
      
          "Returns the maximum system size of given EqSystems"
      
          input list<BackendDAE.EqSystem> inEqSystems;
      
          output Integer outSize = 0;
      
        protected
      
          Integer i;
      
        algorithm
      
          2/2✓ Branch 0 taken 3302 times.
✓ Branch 1 taken 2808 times.

        6110
          for eqSyst in inEqSystems loop
      
        3302
            i := systemSize(eqSyst);
      
            if intGt(i, outSize) then
      
              outSize := i;
      
            end if;
      
          end for;
      
        end maxSizeOfEqSystems;
      
        public function numOfComps "Returns the number of StrongComponents in the EqSystem
      
          author: waurich TUD"
      
          input BackendDAE.EqSystem inEqSystem;
      
          output Integer num;
      
        protected
      
          BackendDAE.StrongComponents comps;
      
        algorithm
      
        ✗
          BackendDAE.MATCHING(comps=comps) := inEqSystem.matching;
      
        ✗
          num := listLength(comps);
      
        end numOfComps;
      
        public function equationArraySizeBDAE
      
        "author: Frenkel TUD
      
          Returns the size of the dae system, which correspondents to the number of variables."
      
          input BackendDAE.BackendDAE inDAE;
      
          output Integer outSize;
      
        algorithm
      
        3088
          outSize := List.applyAndFold(inDAE.eqs, intAdd, equationArraySizeDAE, 0);
      
        end equationArraySizeBDAE;
      
        public function equationArraySizeDAE
      
        "author: Frenkel TUD
      
          Returns the number of equations in a system."
      
          input BackendDAE.EqSystem inEqSystem;
      
          output Integer n = BackendEquation.getNumberOfEquations(inEqSystem.orderedEqs);
      
        end equationArraySizeDAE;
      
        public function hasDAEMatching
      
          "Returns  true if all system have already a matching, otherwise return false."
      
          input BackendDAE.BackendDAE inDAE;
      
          output Boolean b;
      
        algorithm
      
        3901
          b := List.applyAndFold(inDAE.eqs, boolAnd, hasEqSystemMatching, true);
      
        end hasDAEMatching;
      
        public function hasEqSystemMatching
      
          "Returns true if EqSystem has a matching."
      
          input BackendDAE.EqSystem dae;
      
          output Boolean b;
      
        algorithm
      
          b  := match dae
      
            case BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING()) then true;
      
            case BackendDAE.EQSYSTEM(matching=BackendDAE.NO_MATCHING()) then false;
      
          end match;
      
        end hasEqSystemMatching;
      
        protected function generateArrayElements
      
          "Takes a list of identical CREF or ASUB expressions, a list of ICONST indices
      
          and a loop iterator expression, and recursively replaces the loop iterator
      
          with a constant index. Ex:
      
            generateArrayElements(cref[i,j], {1,2,3}, j) =>
      
              {cref[i,1], cref[i,2], cref[i,3]}"
      
          input list<DAE.Exp> clones;
      
          input list<DAE.Exp> indices;
      
          input DAE.Exp iteratorExp;
      
          output list<DAE.Exp> newElements;
      
        algorithm
      
          newElements := match(clones, indices)
      
            local
      
              DAE.Exp clone, newElement, newElement2, index;
      
              list<DAE.Exp> restClones, restIndices, elements;
      
            case ({}, {}) then {};
      
            case (clone::restClones, index::restIndices)
      
              algorithm
      
        ✗
                (newElement, _) := Expression.replaceExp(clone, iteratorExp, index);
      
        ✗
                newElement2 := simplifySubscripts(newElement);
      
        ✗
                elements := generateArrayElements(restClones, restIndices, iteratorExp);
      
              then (newElement2::elements);
      
          end match;
      
        end generateArrayElements;
      
        protected function simplifySubscripts
      
          "Tries to simplify the subscripts of a CREF or ASUB. If an ASUB only contains
      
          constant subscripts, such as cref[1,4], then it also needs to be converted to
      
          a CREF."
      
          input DAE.Exp asub;
      
          output DAE.Exp maybeCref;
      
        algorithm
      
          maybeCref := matchcontinue asub
      
            local
      
              DAE.Ident varIdent;
      
              DAE.Type arrayType, varType;
      
              list<DAE.Exp> subExprs, subExprsSimplified;
      
              list<DAE.Subscript> subscripts;
      
              DAE.Exp newCrefExp;
      
              DAE.ComponentRef cref_;
      
            // A CREF => just simplify the subscripts.
      
            case DAE.CREF(DAE.CREF_IDENT(varIdent, arrayType, subscripts), varType)
      
              algorithm
      
        ✗
                subscripts := List.map(subscripts, simplifySubscript);
      
        ✗
                cref_ := ComponentReferenceBasics.makeCrefIdent(varIdent, arrayType, subscripts);
      
        ✗
                newCrefExp := Expression.makeCrefExp(cref_, varType);
      
              then
      
                newCrefExp;
      
            // An ASUB => convert to CREF if only constant subscripts.
      
            case DAE.ASUB(DAE.CREF(DAE.CREF_IDENT(varIdent, arrayType, _), varType), subscripts)
      
              algorithm
      
        ✗
                subExprs := List.map(subscripts, Expression.getSubscriptExp);
      
        ✗
                {} := List.select(subExprs, Expression.isNotConst);
      
                // If a subscript is not a single constant value it needs to be
      
                // simplified, e.g. cref[3+4] => cref[7], otherwise some subscripts
      
                // might be counted twice, such as cref[3+4] and cref[2+5], even though
      
                // they reference the same element.
      
        ✗
                subExprsSimplified := ExpressionSimplify.simplifyList(subExprs);
      
        ✗
                subscripts := List.map(subExprsSimplified, Expression.makeIndexSubscript);
      
        ✗
                cref_ := ComponentReferenceBasics.makeCrefIdent(varIdent, arrayType, subscripts);
      
        ✗
                newCrefExp := Expression.makeCrefExp(cref_, varType);
      
              then
      
                newCrefExp;
      
            else asub;
      
          end matchcontinue;
      
        end simplifySubscripts;
      
        protected function simplifySubscript
      
          input DAE.Subscript sub;
      
          output DAE.Subscript simplifiedSub;
      
        algorithm
      
          simplifiedSub := matchcontinue sub
      
            local
      
              DAE.Exp e, e1;
      
            case DAE.INDEX(exp = e)
      
              algorithm
      
        ✗
                (e1,_) := ExpressionSimplify.simplify(e);
      
        ✗
              then
      
                if referenceEq(e1,e) then sub else DAE.INDEX(e);
      
            else sub;
      
          end matchcontinue;
      
        end simplifySubscript;
      
        public function setTearingSelectAttribute
      
          "__OpenModelica_tearingSelect is an annotation and has to be extracted from the comment."
      
          input Option<SCode.Comment> optComment;
      
          output Option<BackendDAE.TearingSelect> tearingSelect = NONE();
      
        protected
      
          Option<SCode.Annotation> opt_anno;
      
          SCode.Annotation anno;
      
          SCode.Mod mod;
      
          Option<Absyn.Exp> opt_val;
      
          Absyn.Exp val;
      
          String name;
      
          SourceInfo info;
      
        algorithm
      
        207695
          opt_anno := SCodeUtil.optCommentAnnotation(optComment);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 207695 times.
✓ Branch 2 taken 139827 times.
✓ Branch 3 taken 67868 times.

        207695
          if isNone(opt_anno) then
      
            // No annotation.
      
        139827
            return;
      
          end if;
      
        67868
          SOME(anno) := opt_anno;
      
        67868
          mod := SCodeUtil.lookupAnnotation(anno, "__OpenModelica_tearingSelect");
      
          2/2✓ Branch 1 taken 67860 times.
✓ Branch 2 taken 8 times.

        67868
          if SCodeUtil.isEmptyMod(mod) then
      
        67860
            mod := SCodeUtil.lookupAnnotation(anno, "tearingSelect");
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 67860 times.

        67860
            if not SCodeUtil.isEmptyMod(mod) then
      
        ✗
              Error.addSourceMessage(Error.DEPRECATED_EXPRESSION,
      
                {"tearingSelect", "__OpenModelica_tearingSelect"}, SCodeUtil.getModifierInfo(mod));
      
            end if;
      
          end if;
      
        67868
          opt_val := SCodeUtil.getModifierBinding(mod);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 67868 times.
✓ Branch 2 taken 67860 times.
✓ Branch 3 taken 8 times.

        67868
          if isNone(opt_val) then
      
            // Annotation exists but has no value.
      
        67860
            return;
      
          end if;
      
        8
          SOME(val) := opt_val;
      
        8
          info := SCodeUtil.getModifierInfo(mod);
      
        8
          name := getTearingSelectName(val, info);
      
        8
          tearingSelect := lookupTearingSelectMember(name);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.

        8
          if isNone(tearingSelect) then
      
        ✗
            Error.addSourceMessage(Error.UNKNOWN_ANNOTATION_VALUE, {Dump.printExpStr(val), "__OpenModelica_tearingSelect"}, info);
      
          end if;
      
        end setTearingSelectAttribute;
      
        protected function getTearingSelectName
      
          input Absyn.Exp exp;
      
          input SourceInfo info;
      
          output String name;
      
        algorithm
      
          name := match exp
      
            // TearingSelect.name
      
            case Absyn.Exp.CREF(componentRef =
      
                   Absyn.ComponentRef.CREF_QUAL(name = "TearingSelect", subscripts = {}, componentRef =
      
                     Absyn.ComponentRef.CREF_IDENT(name = name, subscripts = {})))
      
              then name;
      
            // Single name without the TearingSelect prefix is deprecated and no longer accepted.
      
            case Absyn.Exp.CREF(componentRef = Absyn.ComponentRef.CREF_IDENT(name = name, subscripts = {}))
      
              algorithm
      
        ✗
                Error.addSourceMessage(Error.DEPRECATED_EXPRESSION, {name, "TearingSelect." + name}, info);
      
              then
      
                "";
      
            else "";
      
          end match;
      
        end getTearingSelectName;
      
        protected function lookupTearingSelectMember
      
          input String name;
      
          output Option<BackendDAE.TearingSelect> tearingSelect;
      
        algorithm
      
          tearingSelect := match name
      
            case "never"    then SOME(BackendDAE.TearingSelect.NEVER());
      
            case "avoid"    then SOME(BackendDAE.TearingSelect.AVOID());
      
            case "default"  then SOME(BackendDAE.TearingSelect.DEFAULT());
      
            case "prefer"   then SOME(BackendDAE.TearingSelect.PREFER());
      
            case "always"   then SOME(BackendDAE.TearingSelect.ALWAYS());
      
            else NONE();
      
          end match;
      
        end lookupTearingSelectMember;
      
        public function setHideResultAttribute
      
          "Returns the expression of the hideResult annotation.
      
           See Modelica Spec 3.3, section 18.3"
      
          input Option<SCode.Comment> comment;
      
          input DAE.ComponentRef inCref;
      
          output Option<DAE.Exp> hideResult;
      
        protected
      
          DAE.Exp hr;
      
          SCode.Annotation ann;
      
          Absyn.Exp val;
      
          DAE.ComponentRef crefRoot;
      
        algorithm
      
          try
      
          6/8✗ Branch 0 not taken.
✓ Branch 1 taken 349858 times.
✓ Branch 2 taken 317 times.
✓ Branch 3 taken 349541 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 349541 times.
✓ Branch 6 taken 245348 times.
✓ Branch 7 taken 104193 times.

        349858
            SOME(SCode.COMMENT(annotation_=SOME(ann))) := comment;
      
          3/4✗ Branch 1 not taken.
✓ Branch 2 taken 104193 times.
✓ Branch 3 taken 99028 times.
✓ Branch 4 taken 5165 times.

        104193
            SOME(val) := SCodeUtil.lookupAnnotationBinding(ann, "HideResult");
      
        5165
            hr := Expression.fromAbsynExp(val);
      
            hideResult := match inCref
      
              case DAE.CREF_QUAL()
      
                algorithm
      
        5159
                  (crefRoot,_) := ComponentReference.splitCrefLast(inCref);
      
        5159
                  hr := Expression.traverseExpBottomUp(hr, ComponentReference.joinCrefsExp, crefRoot);
      
               then SOME(hr);
      
              else SOME(hr);
      
            end match;
      
          else
      
            hideResult := NONE();
      
          end try;
      
        end setHideResultAttribute;
      
        /*******************************************
      
           Functions that deals with BackendDAE as input
      
        ********************************************/
      
        public function blockIsDynamic "Return true if the block contains a variable that is marked"
      
          input list<Integer> lst;
      
          input array<Integer> arr;
      
          output Boolean outBoolean=true;
      
        algorithm
      
          2/2✓ Branch 0 taken 512361 times.
✓ Branch 1 taken 387656 times.

        900017
          for x in lst loop
      
          2/2✓ Branch 1 taken 43496 times.
✓ Branch 2 taken 468865 times.

        512361
            if arr[x]<>0 then
      
        43496
              return;
      
            end if;
      
          end for;
      
          outBoolean := false;
      
        end blockIsDynamic;
      
        public function markStateEquations "This function goes through all equations and marks the ones that
      
          calculates a state, or is needed in order to calculate a state,
      
          with a non-zero value in the array passed as argument.
      
          This is done by traversing the directed graph of nodes where
      
          a node is an equation/solved variable and following the edges in the
      
          backward direction.
      
          inputs: (daeLow: BackendDAE,
      
                     marks: int array,
      
            adjacencyMatrix: AdjacencyMatrix,
      
            adjacencyMatrixT: AdjacencyMatrixT,
      
            assignments1: int vector,
      
            assignments2: int vector)
      
          outputs: marks: int array"
      
          input BackendDAE.EqSystem syst;
      
          input array<Integer> arr;
      
          input array<Integer> ass1;
      
          output array<Integer> outIntegerArray;
      
        protected
      
          list<Integer> statevarindx_lst,eqns;
      
          BackendDAE.AdjacencyMatrix m;
      
          BackendDAE.Variables v;
      
        algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 51334 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 51334 times.

        51334
          BackendDAE.EQSYSTEM(orderedVars = v,m=SOME(m)) := syst;
      
          2/2✓ Branch 1 taken 54 times.
✓ Branch 2 taken 51280 times.

        51334
          if (Flags.getConfigEnum(Flags.SYM_SOLVER) > 0) then
      
        54
            (_,statevarindx_lst) := BackendVariable.getAllVarIndicesFromVariables(v, BackendVariable.isAlgState);
      
          else
      
        51280
            (_,statevarindx_lst) := BackendVariable.getAllVarIndicesFromVariables(v, BackendVariable.isStateVar);
      
          end if;
      
          5/6✗ Branch 1 not taken.
✓ Branch 2 taken 4622 times.
✓ Branch 3 taken 4622 times.
✓ Branch 4 taken 51334 times.
✓ Branch 5 taken 4622 times.
✓ Branch 6 taken 51334 times.

        55956
          eqns := list(arrayGet(ass1,i) for i guard arrayGet(ass1,i)>0 in statevarindx_lst);
      
        51334
          outIntegerArray := markStateEquationsWork(eqns,m,ass1,arr);
      
        end markStateEquations;
      
        public function zeroCrossingVarIndices
      
          "For every equation system, the indices of its variables that occur in a zero
      
           crossing relation. All systems are resolved against one combined variable set
      
           in a single pass; looking each zero crossing up in every system is quadratic."
      
          input BackendDAE.EqSystems systs;
      
          input list<BackendDAE.ZeroCrossing> zeroCross;
      
          output array<AvlSetInt.Tree> trees;
      
        protected
      
          Integer nsys = listLength(systs), total = 0, gidx = 0, s = 0, n;
      
          BackendDAE.Variables allVars;
      
          array<Integer> sysOf, locOf "combined index -> system / index within that system";
      
          AvlSetInt.Tree tree;
      
        algorithm
      
        2185
          trees := arrayCreate(intMax(nsys, 1), AvlSetInt.new());
      
          2/2✓ Branch 0 taken 51286 times.
✓ Branch 1 taken 2185 times.

        53471
          for syst in systs loop
      
        51286
            total := total + BackendVariable.varsSize(syst.orderedVars);
      
          end for;
      
          2/2✓ Branch 0 taken 124 times.
✓ Branch 1 taken 2061 times.

        2185
          if total == 0 then
      
        124
            return;
      
          end if;
      
        2061
          allVars := BackendVariable.emptyVarsSized(total);
      
        2061
          sysOf := arrayCreate(total, 0);
      
        2061
          locOf := arrayCreate(total, 0);
      
          2/2✓ Branch 0 taken 51178 times.
✓ Branch 1 taken 2061 times.

        53239
          for syst in systs loop
      
        51178
            s := s + 1;
      
        51178
            n := BackendVariable.varsSize(syst.orderedVars);
      
          1/2✓ Branch 0 taken 51178 times.
✗ Branch 1 not taken.

        249065
            for i in 1:n loop
      
        197887
              allVars := BackendVariable.addNewVar(BackendVariable.getVarAt(syst.orderedVars, i), allVars);
      
        197887
              gidx := gidx + 1;
      
        197887
              arrayUpdate(sysOf, gidx, s);
      
        197887
              arrayUpdate(locOf, gidx, i);
      
            end for;
      
          end for;
      
        2061
          tree := AvlSetInt.new();
      
          2/2✓ Branch 0 taken 1713 times.
✓ Branch 1 taken 2061 times.

        3774
          for zc in zeroCross loop
      
        1713
            tree := BackendEquation.expressionVarsIndexes(zc.relation_, tree,
      
                      function BackendEquation.checkEquationsVarsExpTopDown(vars=allVars));
      
          end for;
      
          2/2✓ Branch 1 taken 938 times.
✓ Branch 2 taken 2061 times.

        2999
          for gi in AvlSetInt.listKeys(tree) loop
      
        938
            s := arrayGet(sysOf, gi);
      
        938
            arrayUpdate(trees, s, AvlSetInt.add(arrayGet(trees, s), arrayGet(locOf, gi)));
      
          end for;
      
        end zeroCrossingVarIndices;
      
        public function markZeroCrossingEquations
      
          "Marks the equations needed to evaluate this system's zero crossings by
      
          following the adjacency graph backwards from the variables they use."
      
          input BackendDAE.EqSystem syst;
      
          input AvlSetInt.Tree zcVars "this system's variables occurring in a zero crossing, see zeroCrossingVarIndices";
      
          input array<Integer> arr;
      
          input array<Integer> ass1;
      
          output array<Integer> outIntegerArray;
      
        protected
      
          list<Integer> eqns;
      
          BackendDAE.AdjacencyMatrix m;
      
        algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 51286 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 51286 times.

        51286
          BackendDAE.EQSYSTEM(m=SOME(m)) := syst;
      
          5/6✗ Branch 2 not taken.
✓ Branch 3 taken 938 times.
✓ Branch 4 taken 938 times.
✓ Branch 5 taken 51286 times.
✓ Branch 6 taken 938 times.
✓ Branch 7 taken 51286 times.

        52224
          eqns := list(arrayGet(ass1,i) for i guard arrayGet(ass1,i)>0 in AvlSetInt.listKeys(zcVars));
      
        51286
          outIntegerArray := markStateEquationsWork(eqns,m,ass1,arr);
      
        end markZeroCrossingEquations;
      
        protected function markStateEquationsWork
      
          "Helper function to mark_state_equation
      
          Does the job by looking at variable indexes and adjacency matrix.
      
          inputs: (eqns: int list,
      
                     marks: (int array  BackendDAE.AdjacencyMatrix  int vector  int vector))
      
          outputs: ((marks: int array  BackendDAE.AdjacencyMatrix
      
                int vector  int vector))"
      
          input list<Integer> inEqns;
      
          input BackendDAE.AdjacencyMatrix m;
      
          input array<Integer> ass1;
      
          input array<Integer> iMark;
      
          output array<Integer> oMark = iMark;
      
        protected
      
          list<Integer> queue = inEqns;
      
          Integer j, eqn, len = arrayLength(ass1);
      
          Boolean positiveAndUnmarked;
      
        algorithm
      
          2/2✓ Branch 0 taken 77788 times.
✓ Branch 1 taken 104468 times.

        182256
          while not listEmpty(queue) loop
      
        77788
            eqn :: queue := queue;
      
          2/2✓ Branch 1 taken 17457 times.
✓ Branch 2 taken 60331 times.

        77788
            if oMark[eqn] == 0 then // "Mark an unmarked node/equation"
      
        60331
              arrayUpdate(oMark, eqn, 1);
      
          2/2✓ Branch 1 taken 60331 times.
✓ Branch 2 taken 191480 times.

        251811
              for i in m[eqn] loop
      
          3/4✓ Branch 0 taken 191465 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 191465 times.
✗ Branch 3 not taken.

        191480
                if i>0 and i <= len then
      
                  // We already did bounds checking above
      
        191465
                  j := Dangerous.arrayGetNoBoundsChecking(ass1, i);
      
          3/4✓ Branch 0 taken 191465 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 60647 times.
✓ Branch 4 taken 130818 times.

        191465
                  positiveAndUnmarked := (if j>0 then arrayGet(oMark, j) == 0 else false);
      
                  if positiveAndUnmarked then
      
                    // Only add positive, unmarked variables to the queue
      
                    queue := j::queue;
      
                   end if;
      
                end if;
      
              end for;
      
            end if;
      
          end while;
      
        end markStateEquationsWork;
      
        public function removeNegative
      
        "author: PA
      
          Removes all negative integers."
      
          input list<Integer> lst;
      
          output list<Integer> lst_1;
      
        algorithm
      
        52633
          lst_1 := List.select(lst, Util.intPositive);
      
        end removeNegative;
      
        public function eqnsForVarWithStates
      
        "author: PA
      
          This function returns all equations as a list of equation indices
      
          given a variable as a variable index, including the equations containing
      
          the state variable but not its derivative. This must be used to update
      
          equations when a state is changed to algebraic variable in index reduction
      
          using dummy derivatives.
      
          These equation indices are represented with negative index, thus all
      
          indices are mapped trough int_abs (absolute value).
      
          inputs:  (AdjacencyMatrixT, int /* variable */)
      
          outputs:  int list /* equations */"
      
          input BackendDAE.AdjacencyMatrixT inAdjacencyMatrixT;
      
          input Integer inInteger;
      
          output list<Integer> outIntegerLst;
      
        algorithm
      
          outIntegerLst := matchcontinue (inAdjacencyMatrixT,inInteger)
      
            local
      
              Integer n,indx;
      
              list<Integer> res,res_1;
      
              array<list<Integer>> mt;
      
              String s;
      
            case (mt,n)
      
              algorithm
      
        ✗
                res := mt[n];
      
        ✗
                res_1 := List.map(res, intAbs);
      
              then
      
                res_1;
      
            case (_,indx)
      
              algorithm
      
        ✗
                print("- BackendDAEUtil.eqnsForVarWithStates failed, indx= ");
      
        ✗
                s := intString(indx);
      
        ✗
                print(s);
      
        ✗
                print("\n");
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end eqnsForVarWithStates;
      
        public function varsInEqn
      
        "author: PA
      
          This function returns all variable indices as a list for
      
          a given equation, given as an equation index. (1...n)
      
          Negative indexes are removed.
      
          See also: eqnsForVar and eqnsForVarWithStates
      
          inputs:  (AdjacencyMatrix, int /* equation */)
      
          outputs:  int list /* variables */"
      
          input BackendDAE.AdjacencyMatrix m;
      
          input Integer indx;
      
          output list<Integer> outIntegerLst;
      
        algorithm
      
          outIntegerLst := matchcontinue indx
      
            local String s;
      
            case _
      
        52633
              then
      
                removeNegative(m[indx]);
      
            else
      
              algorithm
      
        ✗
                s := "- BackendDAEUtil.varsInEqn failed, indx= " + intString(indx) + "array length: " + intString(arrayLength(m)) + "\n";
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{s});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end varsInEqn;
      
        protected type TraverseIndicesTuple = tuple<list<Integer>, list<Integer>, list<Integer>>;
      
        public function setEvaluationStage
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          output BackendDAE.BackendDAE outBackendDAE;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqns;
      
          BackendDAE.Matching matching;
      
          list<Integer> indicesDynamic, indicesDiscrete, indicesAlgebraic;
      
          TraverseIndicesTuple traverseArgs;
      
          array<Integer> assigndEqn, assigndVar, markedEqns;
      
          BackendDAE.EqSystems newEqs = {};
      
          BackendDAE.AdjacencyMatrix adjMatrix, adjMatrixT;
      
          list<BackendDAE.ZeroCrossing> zeroCrossings;
      
          array<AvlSetInt.Tree> zcVars;
      
          Integer sysIdx = 0;
      
          constant Boolean debug = false;
      
        algorithm
      
          // get zeroCrossings
      
        9
          zeroCrossings := ZeroCrossings.toList(inBackendDAE.shared.eventInfo.zeroCrossings);
      
        9
          zcVars := zeroCrossingVarIndices(inBackendDAE.eqs, zeroCrossings);
      
          // walk once through all comps and get of dependends of dynamic, algebraic, zeroCrossings,
      
          2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 9 times.

        22
          for eqSystem in inBackendDAE.eqs loop
      
        13
            sysIdx := sysIdx + 1;
      
            if debug then
      
              BackendDump.printEqSystem(eqSystem);
      
            end if;
      
            vars := eqSystem.orderedVars;
      
        13
            eqns := eqSystem.orderedEqs;
      
            try
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.

        13
              matching as BackendDAE.MATCHING(ass2=assigndEqn,ass1=assigndVar) := eqSystem.matching;
      
        13
              (eqSystem, adjMatrix, adjMatrixT) := getAdjacencyMatrixfromOption(eqSystem, BackendDAE.ABSOLUTE(), SOME(inBackendDAE.shared.functionTree), BackendDAEUtil.isInitializationDAE(inBackendDAE.shared));
      
              // collect all dynamic, discrete, algebraic equations
      
              traverseArgs := ({}, {}, {});
      
        13
              traverseArgs := BackendDAEUtil.traverseEqSystemStrongComponents(eqSystem, collectEqnsIndexByKind, traverseArgs);
      
        13
              (indicesDynamic, indicesDiscrete, indicesAlgebraic) := traverseArgs;
      
              if debug then
      
                print("Dynamic equation indicies:\n");
      
                print(stringDelimitList(list(intString(i) for i in indicesDynamic), ", "));
      
                print("\n");
      
              end if;
      
        13
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqns), 0);
      
        13
              markedEqns := markStateEquationsWork(indicesDynamic, adjMatrix, assigndVar, markedEqns);
      
        13
              eqns := setMarkedEqnsEvalStage(eqns, markedEqns, BackendEquation.setEvalStageDynamic);
      
        13
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqns), 0);
      
        13
              markedEqns := markZeroCrossingEquations(eqSystem, arrayGet(zcVars, sysIdx), markedEqns, assigndVar);
      
        13
              eqns := setMarkedEqnsEvalStage(eqns, markedEqns, BackendEquation.setEvalStageZeroCross);
      
        13
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqns), 0);
      
        13
              markedEqns := markStateEquationsWork(indicesAlgebraic, adjMatrix, assigndVar, markedEqns);
      
        13
              eqns := setMarkedEqnsEvalStage(eqns, markedEqns, BackendEquation.setEvalStageAlgebraic);
      
        13
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqSystem.removedEqs), 1);
      
        13
              eqSystem.removedEqs := setMarkedEqnsEvalStage(eqSystem.removedEqs, markedEqns, BackendEquation.setEvalStageDiscrete);
      
              /* For now avoid this and evaluate all the event update breaks right now
      
                 quite a lot models.
      
              */
      
        13
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqns), 1);
      
              //markedEqns := markStateEquationsWork(indicesDiscrete, adjMatrix, assigndVar, markedEqns);
      
              //markedEqns := markStateEquationsWork(indicesDiscrete, adjMatrixT, assigndVar, markedEqns);
      
        13
              eqns := setMarkedEqnsEvalStage(eqns, markedEqns, BackendEquation.setEvalStageDiscrete);
      
            else
      
              /* in case something goes wrong above mark all equation to be evaluated always */
      
        ✗
              markedEqns := arrayCreate(BackendEquation.getNumberOfEquations(eqns), 1);
      
        ✗
              eqns := setMarkedEqnsEvalStage(eqns, markedEqns, BackendEquation.setEvalStageAll);
      
            end try;
      
            if debug then
      
              BackendDump.dumpEquationArray(eqns, "Updated equations");
      
            end if;
      
            // update EvaluationState in EquationArray
      
            newEqs := eqSystem::newEqs;
      
          end for;
      
          // update BackendDAE.DAE
      
        9
          outBackendDAE := BackendDAE.DAE(newEqs, inBackendDAE.shared);
      
        end setEvaluationStage;
      
        protected function setMarkedEqnsEvalStage
      
          input output BackendDAE.EquationArray eqns;
      
          input array<Integer> markEqns;
      
          input setEvalStage func;
      
          partial function setEvalStage
      
            input output BackendDAE.EvaluationStages evalStage;
      
          end setEvalStage;
      
        protected
      
          BackendDAE.Equation eqn;
      
        algorithm
      
          2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 59 times.

        20863
          for i in 1:arrayLength(markEqns) loop
      
          2/2✓ Branch 1 taken 10649 times.
✓ Branch 2 taken 10149 times.

        20798
            if markEqns[i]>0 then
      
        10649
              eqn := BackendEquation.get(eqns, i);
      
        10649
              eqn := BackendEquation.setEquationEvalStage(eqn, func);
      
        10649
              eqns := BackendEquation.setAtIndex(eqns, i, eqn);
      
            end if;
      
          end for;
      
        end setMarkedEqnsEvalStage;
      
        protected function collectEqnsIndexByKind
      
        "This function collects equation indices by kind.
      
         "
      
          input list<BackendDAE.Equation> inEqns;
      
          input list<BackendDAE.Var> inVars;
      
          input list<Integer> varIdxs;
      
          input list<Integer> eqnIdxs;
      
          input output TraverseIndicesTuple traverserArgs;
      
        protected
      
          list<Integer> indicesDynamic, indicesDiscrete, indicesAlgebraic;
      
        algorithm
      
        5192
          (indicesDynamic, indicesDiscrete, indicesAlgebraic) := traverserArgs;
      
          2/2✓ Branch 0 taken 5366 times.
✓ Branch 1 taken 5192 times.

        10558
          for v in inVars loop
      
            // discrete equations are detected by the corresponding variables
      
          2/2✓ Branch 1 taken 91 times.
✓ Branch 2 taken 5275 times.

        5366
            if BackendVariable.isVarDiscrete(v) then
      
        91
              indicesDiscrete := listAppend(eqnIdxs, indicesDiscrete);
      
            end if;
      
          end for;
      
          2/2✓ Branch 0 taken 5192 times.
✓ Branch 1 taken 5192 times.

        10384
          for eq in inEqns loop
      
            // dynamic
      
          2/2✓ Branch 1 taken 3800 times.
✓ Branch 2 taken 1392 times.

        5192
            if BackendEquation.isDynamicEquation(eq) then
      
        3800
              indicesDynamic := listAppend(eqnIdxs, indicesDynamic);
      
            end if;
      
            // select also continuos equation
      
          2/2✓ Branch 1 taken 1375 times.
✓ Branch 2 taken 3817 times.

        5192
            if BackendEquation.isAuxEquation(eq) then
      
        1375
              indicesAlgebraic := listAppend(eqnIdxs, indicesAlgebraic);
      
            end if;
      
          end for;
      
        5192
          traverserArgs := (indicesDynamic, indicesDiscrete, indicesAlgebraic);
      
        end collectEqnsIndexByKind;
      
        public function subscript2dCombinations
      
        "This function takes two lists of list of subscripts and combines them in
      
          all possible combinations. This is used when finding all indexes of a 2d
      
          array.
      
          For instance, subscript2dCombinations({{a},{b},{c}},{{x},{y},{z}})
      
          => {{a,x},{a,y},{a,z},{b,x},{b,y},{b,z},{c,x},{c,y},{c,z}}
      
          inputs:  (DAE.Subscript list list /* dim1 subs */,
      
                      DAE.Subscript list list /* dim2 subs */)
      
          outputs: (DAE.Subscript list list)"
      
          input list<list<DAE.Subscript>> inExpSubscriptLstLst1;
      
          input list<list<DAE.Subscript>> inExpSubscriptLstLst2;
      
          output list<list<DAE.Subscript>> outExpSubscriptLstLst;
      
        algorithm
      
          outExpSubscriptLstLst := match (inExpSubscriptLstLst1,inExpSubscriptLstLst2)
      
            local
      
              list<list<DAE.Subscript>> lst1,lst2,res,ss,ss2;
      
              list<DAE.Subscript> s1;
      
            case ({},_) then {};
      
            case ((s1::ss),ss2)
      
              algorithm
      
        ✗
                lst1 := subscript2dCombinations2(s1, ss2);
      
        ✗
                lst2 := subscript2dCombinations(ss, ss2);
      
        ✗
                res := listAppend(lst1, lst2);
      
              then
      
                res;
      
          end match;
      
        end subscript2dCombinations;
      
        protected function subscript2dCombinations2
      
          input list<DAE.Subscript> inExpSubscriptLst;
      
          input list<list<DAE.Subscript>> inExpSubscriptLstLst;
      
          output list<list<DAE.Subscript>> outExpSubscriptLstLst;
      
        algorithm
      
          outExpSubscriptLstLst := match (inExpSubscriptLst,inExpSubscriptLstLst)
      
            local
      
              list<list<DAE.Subscript>> lst1,ss2;
      
              list<DAE.Subscript> elt1,ss,s2;
      
            case (_,{}) then {};
      
            case (ss,(s2::ss2))
      
              algorithm
      
        ✗
                lst1 := subscript2dCombinations2(ss, ss2);
      
        ✗
                elt1 := listAppend(ss, s2);
      
              then
      
                (elt1::lst1);
      
          end match;
      
        end subscript2dCombinations2;
      
        public function splitoutEquationAndVars
      
        " author: wbraun"
      
          input BackendDAE.StrongComponents inNeededBlocks;
      
          input BackendDAE.EquationArray inEqns;
      
          input BackendDAE.Variables inVars;
      
          input BackendDAE.EquationArray inEqnsNew;
      
          input BackendDAE.Variables inVarsNew;
      
          output BackendDAE.EquationArray outEqns;
      
          output BackendDAE.Variables outVars;
      
        algorithm
      
          (outEqns,outVars) := match(inNeededBlocks, inEqnsNew, inVarsNew)
      
          local
      
            BackendDAE.StrongComponent comp;
      
            BackendDAE.StrongComponents rest;
      
            list<BackendDAE.Equation> eqn_lst;
      
            list<BackendDAE.Var> var_lst;
      
            BackendDAE.EquationArray eqnsNew;
      
            BackendDAE.Variables varsNew;
      
            case ({}, eqnsNew, varsNew) then (eqnsNew,varsNew);
      
            case (comp::rest, eqnsNew, varsNew)
      
              algorithm
      
        ✗
              (eqnsNew,varsNew) := splitoutEquationAndVars(rest,inEqns,inVars,eqnsNew,varsNew);
      
        ✗
              (eqn_lst,var_lst,_) := BackendDAETransform.getEquationAndSolvedVar(comp, inEqns, inVars);
      
        ✗
              eqnsNew := BackendEquation.addList(eqn_lst, eqnsNew);
      
        ✗
              varsNew := BackendVariable.addVars(var_lst, varsNew);
      
            then (eqnsNew,varsNew);
      
         end match;
      
        end splitoutEquationAndVars;
      
        public function getStrongComponents
      
        "author: Frenkel TUD 2011-11
      
          This function returns the strongComponents of a BackendDAE."
      
          input BackendDAE.EqSystem syst;
      
          output BackendDAE.StrongComponents outComps;
      
        algorithm
      
          outComps := match syst
      
            case BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=outComps)) then outComps;
      
            else {};
      
          end match;
      
        end getStrongComponents;
      
        public function getFunctions
      
        "author: Frenkel TUD 2011-11
      
          This function returns the Functions of a BackendDAE."
      
          input BackendDAE.Shared shared;
      
          output AvlTreePathFunction.Tree functionTree;
      
        algorithm
      
        432417
          BackendDAE.SHARED(functionTree=functionTree) := shared;
      
        end getFunctions;
      
        public function getGlobalKnownVarsFromShared
      
        "function: getFunctions
      
          author: Frenkel TUD 2011-11
      
          This function returns known variable of a BackendDAE."
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.Variables globalKnownVars;
      
        algorithm
      
        162834
          BackendDAE.SHARED(globalKnownVars=globalKnownVars) := shared;
      
        end getGlobalKnownVarsFromShared;
      
        public function getExtraInfo
      
        "function: getExtraInfo
      
          This function returns extra info of a BackendDAE."
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.ExtraInfo einfo;
      
        algorithm
      
        2293
          BackendDAE.SHARED(info=einfo) := shared;
      
        end getExtraInfo;
      
        public function reduceEqSystemsInDAE
      
        "Function reduces BackendDAE system by filtering
      
        the equation and select only the one that are needed
      
        to calculate the given varibales.
      
        "
      
          input BackendDAE.BackendDAE inDAE;
      
          input list<BackendDAE.Var> iVarlst;
      
          input Boolean makeMatching = true;
      
          input Boolean filterDiscretes = false;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.Shared shared;
      
          list<BackendDAE.EqSystem> systs;
      
        algorithm
      
        1820
          BackendDAE.DAE(systs, shared) := inDAE;
      
          4/4✓ Branch 0 taken 1820 times.
✓ Branch 1 taken 1820 times.
✓ Branch 2 taken 1820 times.
✓ Branch 3 taken 1820 times.

        3640
          outDAE := BackendDAE.DAE(list(tryReduceEqSystem(syst, shared, iVarlst, filterDiscretes) for syst in systs), shared);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1820 times.

        1820
          if makeMatching then
      
        1820
            outDAE := BackendDAEUtil.transformBackendDAE(outDAE,SOME((BackendDAE.NO_INDEX_REDUCTION(),BackendDAE.EXACT())),NONE(),NONE());
      
          end if;
      
        end reduceEqSystemsInDAE;
      
        public function tryReduceEqSystem
      
        " Helpfunction to reduceEqSystemsInDAE.
      
        "
      
          input BackendDAE.EqSystem iSyst;
      
          input BackendDAE.Shared shared;
      
          input list<BackendDAE.Var> iVarlst;
      
          input Boolean filterDiscretes;
      
          output BackendDAE.EqSystem oSyst;
      
        algorithm
      
          try
      
            //BackendDump.dumpEqSystem(iSyst,"IN: tryReduceEqSystem");
      
        1822
            oSyst := reduceEqSystem(iSyst, shared, iVarlst, filterDiscretes);
      
            //BackendDump.dumpEqSystem(oSyst,"OUT: tryReduceEqSystem");
      
          else
      
            oSyst := iSyst;
      
          end try;
      
        end tryReduceEqSystem;
      
        public function reduceEqSystem
      
        "Function reduces BackendDAE.EqSystem system by filtering
      
        the equation and select only the one that are needed
      
        to calculate the given varibales. Shared object is used
      
        only to get the functionsTree.
      
        "
      
          input BackendDAE.EqSystem iSyst;
      
          input BackendDAE.Shared shared;
      
          input list<BackendDAE.Var> iVarlst;
      
          input Boolean filterDiscretes;
      
          output BackendDAE.EqSystem oSyst;
      
        protected
      
          array<Integer> ass1, ass2;
      
          BackendDAE.Variables vars;
      
          BackendDAE.EqSystem syst;
      
          BackendDAE.Variables iVars = BackendVariable.listVar(iVarlst);
      
          BackendDAE.EquationArray ordererdEqs, arrEqs;
      
          list<Integer> indx_lst_v, indx_lst_e, statevarindx_lst;
      
          array<Integer> indx_arr;
      
          list<BackendDAE.Equation> el;
      
          list<BackendDAE.Var> vl;
      
          AvlTreePathFunction.Tree funcs;
      
          BackendDAE.AdjacencyMatrix m;
      
        algorithm
      
          oSyst := match iSyst
      
            case syst as BackendDAE.EQSYSTEM( orderedEqs=ordererdEqs, orderedVars=vars,
      
                                              matching=BackendDAE.MATCHING(ass1=ass1, ass2=ass2) )
      
              algorithm
      
          2/2✓ Branch 1 taken 8 times.
✓ Branch 2 taken 1814 times.

        1822
                if (Flags.getConfigEnum(Flags.SYM_SOLVER) > 0) then
      
        8
                  (_,statevarindx_lst) := BackendVariable.getAllVarIndicesFromVariables(vars, BackendVariable.isAlgState);
      
                else
      
        1814
                  (_,statevarindx_lst) := BackendVariable.getAllVarIndicesFromVariables(vars, BackendVariable.isStateVar);
      
                end if;
      
        1822
                indx_lst_v := BackendVariable.getVarIndexFromVariables(iVars, vars);
      
        1822
                indx_lst_v := listAppend(indx_lst_v, statevarindx_lst) "overestimate" annotation(__OpenModelica_DisableListAppendWarning=true);
      
        1822
                indx_lst_e := List.map1r(indx_lst_v, arrayGet, ass1);
      
        1822
                indx_arr := arrayCreate(equationArraySizeDAE(iSyst), 0);
      
        1822
                funcs := getFunctions(shared);
      
        3644
                (_, m, _) := getAdjacencyMatrix(iSyst, BackendDAE.SPARSE(), SOME(funcs), isInitializationDAE(shared));
      
        1822
                indx_arr := markStateEquationsWork(indx_lst_e,  m, ass1, indx_arr);
      
        1822
                indx_lst_e := Array.foldIndex(indx_arr, translateArrayList, {});
      
        1822
                el := BackendEquation.getList(indx_lst_e, ordererdEqs);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1822 times.

        1822
                if filterDiscretes then
      
        ✗
                  el := list(e for e guard(not BackendEquation.isDiscreteEquation(e)) in el);
      
                end if;
      
        1822
                arrEqs := BackendEquation.listEquation(el);
      
        1822
                vl := BackendEquation.equationsVars(arrEqs, vars);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1822 times.

        1822
                if filterDiscretes then
      
        ✗
                  vl := list(v for v guard(not BackendVariable.isVarDiscrete(v)) in vl);
      
                end if;
      
        1822
                syst.orderedVars := BackendVariable.listVar1(vl);
      
        1822
                syst.orderedEqs := arrEqs;
      
        1822
                syst.stateSets := {};
      
        1822
              then clearEqSyst(syst);
      
          end match;
      
        end reduceEqSystem;
      
        public function introduceOutputRealDerivatives
      
        "Find output variables of Real type and replace them with derivative equation
      
         (e.g) output Real y;
      
          $y_der = der(y)
      
         "
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystem currentSystem;
      
          DAE.ComponentRef newCref;
      
          DAE.Exp lhs, rhs;
      
          list<BackendDAE.Equation> newEqnlst;
      
          list<BackendDAE.Var> daeVarsLst;
      
        algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.

        8
          {currentSystem} := inDAE.eqs;
      
          daeVarsLst := {};
      
          newEqnlst := {};
      
          2/2✓ Branch 1 taken 976 times.
✓ Branch 2 taken 8 times.

        984
          for var in BackendVariable.varList(currentSystem.orderedVars) loop
      
          3/4✓ Branch 1 taken 2 times.
✓ Branch 2 taken 974 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.

        976
            if BackendVariable.isOutputVar(var) and BackendVariable.isRealVar(var) then
      
        2
              newCref := ComponentReference.appendStringLastIdent("_der", var.varName); // append _der
      
        2
              newCref := ComponentReference.prependStringCref("$", newCref); // prepend $
      
        2
              daeVarsLst := BackendVariable.makeVar(newCref) :: daeVarsLst;
      
        2
              lhs := Expression.crefExp(newCref);
      
        2
              rhs := IndexReduction.makeder(BackendVariable.varExp(var));
      
        2
              newEqnlst := BackendEquation.generateEquation(lhs, rhs, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_BINDING) :: newEqnlst;
      
            end if;
      
          end for;
      
          //BackendDump.dumpEquationList(newEqnlst, "first order derivative equation");
      
        8
          currentSystem := BackendVariable.addVarsDAE(daeVarsLst, currentSystem);
      
        8
          currentSystem.orderedEqs := BackendEquation.merge(currentSystem.orderedEqs, BackendEquation.listEquation(newEqnlst));
      
        8
          outDAE := BackendDAE.DAE({currentSystem}, inDAE.shared);
      
          //BackendDump.printBackendDAE(outDAE);
      
        end introduceOutputRealDerivatives;
      
        public function introduceOutputAliases
      
        "Find top level output variables and replace them with alias variables."
      
          input output BackendDAE.BackendDAE dae;
      
        protected
      
          BackendDAE.EqSystems systems, returnSysts = {};
      
          BackendDAE.Variables vars, newVars;
      
          BackendDAE.EquationArray eqs, removedEqs;
      
          list<BackendDAE.Equation> newEqns, newRemovedEqs;
      
          DAE.ComponentRef newCref, cref;
      
          BackendDAE.Var newVar;
      
          BackendDAE.Equation newEqn;
      
          HashSet.HashSet topLevelOutputs = HashSet.emptyHashSet();
      
        algorithm
      
        83
          systems := dae.eqs;
      
          2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 83 times.

        166
          for system in systems loop
      
        83
            eqs := system.orderedEqs;
      
        83
            vars := system.orderedVars;
      
        83
            removedEqs := system.removedEqs;
      
        83
            newVars := BackendVariable.emptyVarsSized(realInt(intReal(BackendVariable.varsSize(vars)) * 1.4));
      
            newEqns := {};
      
            newRemovedEqs := {};
      
            // Add alias variable and alias equation
      
          2/2✓ Branch 1 taken 7299 times.
✓ Branch 2 taken 83 times.

        7382
            for v in BackendVariable.varList(vars) loop
      
          2/2✓ Branch 1 taken 7183 times.
✓ Branch 2 taken 116 times.

        7299
              if not BackendVariable.isVarOnTopLevelAndOutput(v) then
      
        7183
                newVars := BackendVariable.addVar(v, newVars);
      
              else
      
        116
                cref := BackendVariable.varCref(v);
      
        116
                topLevelOutputs := BaseHashSet.add(cref, topLevelOutputs);
      
                // generate new internal alias var
      
        116
                newCref := ComponentReference.prependStringCref(BackendDAE.outputAliasPrefix, cref);
      
        116
                newVar := BackendVariable.copyVarNewName(newCref, v);
      
        116
                newVar := BackendVariable.setVarDirection(newVar, DAE.BIDIR());
      
                /* A discrete output's alias stays discrete; as a continuous variable it
      
                 * also gets "$PRE.alias = alias", which over-specifies the initial system.
      
                 */
      
                newVar := match v.varKind
      
                  case BackendDAE.DISCRETE() then newVar;
      
        69
                  else BackendVariable.setVarKind(newVar, BackendDAE.VARIABLE());
      
                end match;
      
                /* fix issue https://github.com/OpenModelica/OpenModelica/issues/15311
      
                 * force StateSelect.never on the alias variable so that state selection never picks the alias
      
                 * instead of original state variable, which would cause wrong code generation and simulation results.
      
                 */
      
          2/2✓ Branch 1 taken 109 times.
✓ Branch 2 taken 7 times.

        116
                if BackendVariable.isRealVar(v) then
      
        109
                  newVar := BackendVariable.setVarStateSelect(newVar, DAE.AVOID());
      
                end if;
      
        116
                newVars := BackendVariable.addVar(newVar, newVars);
      
                /*fix issue https://github.com/OpenModelica/OpenModelica/issues/13342
      
                 *do not change the varkind of the output variable, except if var = BackendDAE.STATE()
      
                */
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 116 times.

        116
                if BackendVariable.isStateVar(v) then
      
        ✗
                  v := BackendVariable.setVarKind(v, BackendDAE.VARIABLE());
      
                end if;
      
        116
                v := BackendVariable.removeFixedAttribute(v);
      
        116
                v := BackendVariable.removeStartAttribute(v);
      
        116
                newVars := BackendVariable.addVar(v, newVars);
      
                // generate new equation and add it
      
        116
                newEqn := BackendEquation.generateEquation(Expression.crefToExp(cref), Expression.crefToExp(newCref), DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_BINDING);
      
                newEqns := newEqn::newEqns;
      
              end if;
      
            end for;
      
            // Replace variable with alias variable in all equations
      
        83
            traverseBackendDAEExpsEqns(eqs, introduceOutputAliases_eqs, topLevelOutputs);
      
        83
            eqs := BackendEquation.addList(newEqns, eqs);
      
        83
            traverseBackendDAEExpsEqns(removedEqs, introduceOutputAliases_eqs, topLevelOutputs);
      
        83
            removedEqs := BackendEquation.addList(newRemovedEqs, removedEqs);
      
            // Update system
      
        83
            system.orderedVars := newVars;
      
            system.orderedEqs := eqs;
      
            system.removedEqs := removedEqs;
      
            returnSysts := system::returnSysts;
      
          end for;
      
        83
          returnSysts := listReverse(returnSysts);
      
        83
          dae.eqs := returnSysts;
      
        end introduceOutputAliases;
      
        protected function introduceOutputAliases_eqs
      
          input DAE.Exp inExp;
      
          input HashSet.HashSet inStates;
      
          output DAE.Exp outExp;
      
          output HashSet.HashSet outStates;
      
        algorithm
      
        9251
          (outExp, outStates) := Expression.traverseExpBottomUp(inExp, introduceOutputAliases_eqs2, inStates);
      
        end introduceOutputAliases_eqs;
      
        protected function introduceOutputAliases_eqs2
      
          input DAE.Exp inExp;
      
          input HashSet.HashSet inStates;
      
          output DAE.Exp outExp;
      
          output HashSet.HashSet outStates = inStates;
      
        algorithm
      
          outExp := match inExp
      
            local
      
              DAE.Exp e1;
      
              DAE.ComponentRef cr, newCref;
      
            // replace cr with <outputAliasPrefix>+cr
      
            case e1 as DAE.CREF(componentRef=cr) guard BaseHashSet.has(cr, inStates) algorithm
      
        75
              newCref := ComponentReference.prependStringCref(BackendDAE.outputAliasPrefix, cr);
      
        75
              e1.componentRef := newCref;
      
            then e1;
      
            else inExp;
      
          end match;
      
        end introduceOutputAliases_eqs2;
      
        protected function translateArrayList
      
          input Integer inElement;
      
          input Integer inIndex;
      
          input list<Integer> inFoldArg;
      
          output list<Integer> outFoldArg;
      
        algorithm
      
          2/2✓ Branch 0 taken 18288 times.
✓ Branch 1 taken 655 times.

        18943
          outFoldArg := if intEq(inElement, 1) then inIndex::inFoldArg else inFoldArg;
      
        end translateArrayList;
      
        public function removeDiscreteAssignments "
      
        Author: wbraun
      
        Function tarverse Statements and remove discrete one"
      
          input list<DAE.Statement> inStmts;
      
          input BackendDAE.Variables inVars;
      
          output list<DAE.Statement> outStmts;
      
        algorithm
      
          outStmts := matchcontinue(inStmts,inVars)
      
            local
      
              list<DAE.Statement> stmts,rest,xs;
      
              DAE.Else algElse;
      
              DAE.Statement stmt,ew;
      
              DAE.ComponentRef cref;
      
              BackendDAE.Var v;
      
              BackendDAE.Variables vars;
      
              DAE.Exp e;
      
              DAE.ElementSource source;
      
              DAE.Type tp;
      
              Boolean b1;
      
              String id1;
      
              list<DAE.ComponentRef> conditions;
      
              Boolean initialCall;
      
              list<tuple<DAE.ComponentRef, array<DAE.Exp>>> sub_iters;
      
            case ({},_) then ({});
      
            case ((DAE.STMT_ASSIGN(exp1 = e)::rest),vars)
      
              algorithm
      
        ✗
                cref := Expression.expCref(e);
      
        ✗
                ({v},_) := BackendVariable.getVar(cref,vars);
      
        ✗
                true := BackendVariable.isVarDiscrete(v);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
              then xs;
      
            /*case ((DAE.STMT_TUPLE_ASSIGN(expExpLst = expl1)::rest),vars)
      
              algorithm
      
                crefLst = List.map(expl1,Expression.expCref);
      
                (vlst,_) = List.map1_2(crefLst,BackendVariable.getVar,vars);
      
                //blst = List.map(vlst,BackendVariable.isVarDiscrete);
      
                //true = boolOrList(blst);
      
                xs = removeDiscreteAssignments(rest,vars);
      
              then xs;
      
              */
      
            case ((DAE.STMT_ASSIGN_ARR(lhs = e)::rest),vars)
      
              algorithm
      
        ✗
                cref := Expression.expCref(e);
      
        ✗
                ({v},_) := BackendVariable.getVar(cref,vars);
      
        ✗
                true := BackendVariable.isVarDiscrete(v);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
              then xs;
      
            case (((DAE.STMT_IF(exp=e,statementLst=stmts,else_ = algElse, source = source))::rest),vars)
      
              algorithm
      
        ✗
                stmts := removeDiscreteAssignments(stmts,vars);
      
        ✗
                algElse := removediscreteAssingmentsElse(algElse,vars);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
        ✗
              then DAE.STMT_IF(e,stmts,algElse,source)::xs;
      
            case (((DAE.STMT_FOR(type_=tp,iterIsArray=b1,iter=id1,range=e,statementLst=stmts, source = source, sub_iters=sub_iters))::rest),vars)
      
              algorithm
      
        ✗
                stmts := removeDiscreteAssignments(stmts,vars);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
        ✗
              then DAE.STMT_FOR(tp,b1,id1,e,stmts,source,sub_iters)::xs;
      
            case (((DAE.STMT_WHILE(exp=e,statementLst=stmts, source = source))::rest),vars)
      
              algorithm
      
        ✗
                stmts := removeDiscreteAssignments(stmts,vars);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
        ✗
              then DAE.STMT_WHILE(e,stmts,source)::xs;
      
            case (((DAE.STMT_WHEN(exp=e,conditions=conditions,initialCall=initialCall,statementLst=stmts,elseWhen=NONE(),source=source))::rest),vars)
      
              algorithm
      
        ✗
                stmts := removeDiscreteAssignments(stmts,vars);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
        ✗
              then DAE.STMT_WHEN(e,conditions,initialCall,stmts,NONE(),source)::xs;
      
            case (((DAE.STMT_WHEN(exp=e,conditions=conditions,initialCall=initialCall,statementLst=stmts,elseWhen=SOME(ew),source=source))::rest),vars)
      
              algorithm
      
        ✗
                stmts := removeDiscreteAssignments(stmts,vars);
      
        ✗
                {ew} := removeDiscreteAssignments({ew},vars);
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
        ✗
              then DAE.STMT_WHEN(e,conditions,initialCall,stmts,SOME(ew),source)::xs;
      
            case ((stmt::rest),vars)
      
              algorithm
      
        ✗
                xs := removeDiscreteAssignments(rest,vars);
      
              then  stmt::xs;
      
          end matchcontinue;
      
        end removeDiscreteAssignments;
      
        protected function removediscreteAssingmentsElse "author: wbraun
      
          Helper function for traverseDAEEquationsELse"
      
          input DAE.Else inElse;
      
          input BackendDAE.Variables inVars;
      
          output DAE.Else outElse;
      
        algorithm
      
          outElse := match(inElse,inVars)
      
          local
      
            DAE.Exp e;
      
            list<DAE.Statement> st;
      
            DAE.Else el;
      
            BackendDAE.Variables vars;
      
          case(DAE.NOELSE(),_) then (DAE.NOELSE());
      
          case(DAE.ELSEIF(e,st,el),vars)
      
            algorithm
      
        ✗
              el := removediscreteAssingmentsElse(el,vars);
      
        ✗
              st := removeDiscreteAssignments(st,vars);
      
        ✗
            then DAE.ELSEIF(e,st,el);
      
          case(DAE.ELSE(st),vars)
      
            algorithm
      
        ✗
              st := removeDiscreteAssignments(st,vars);
      
        ✗
            then DAE.ELSE(st);
      
        end match;
      
        end removediscreteAssingmentsElse;
      
        public function collateAlgorithm "
      
        Author: Frenkel TUD 2010-07"
      
          input DAE.Algorithm inAlg;
      
          input Option<AvlTreePathFunction.Tree> infuncs;
      
          output DAE.Algorithm outAlg;
      
        algorithm
      
          outAlg := matchcontinue inAlg
      
            local list<DAE.Statement> statementLst;
      
            case DAE.ALGORITHM_STMTS(statementLst=statementLst)
      
              algorithm
      
        34466
                (statementLst,_) := DAEUtil.traverseDAEStmts(statementLst, collateArrExpStmt, infuncs);
      
        34466
              then
      
                DAE.ALGORITHM_STMTS(statementLst);
      
            else inAlg;
      
          end matchcontinue;
      
        end collateAlgorithm;
      
        protected function collateArrExpStmt "author: Frenkel TUD 2010-07
      
          wbraun: added as workaround for when condition.
      
          As long as we don't support fully array helpVars,
      
          we can't collate the expression of a when condition."
      
          input DAE.Exp inExp;
      
          input DAE.Statement inStmt;
      
          input Option<AvlTreePathFunction.Tree> funcs;
      
          output DAE.Exp outExp = inExp;
      
          output Option<AvlTreePathFunction.Tree> oarg = funcs;
      
        algorithm
      
          try
      
        111497
            outExp := Expression.traverseExpBottomUp(outExp, traversingcollateArrExpStmt, (inStmt, funcs));
      
          else
      
          end try;
      
        end collateArrExpStmt;
      
        protected function traversingcollateArrExpStmt "wbraun: added as workaround for when condition.
      
          As long as we don't support fully array helpVars,
      
          we can't collate the expression of a when condition."
      
          input DAE.Exp inExp;
      
          input tuple<DAE.Statement, Option<AvlTreePathFunction.Tree>> inTpl;
      
          output DAE.Exp outExp;
      
          output tuple<DAE.Statement, Option<AvlTreePathFunction.Tree>> outTpl;
      
        algorithm
      
          (outExp,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              DAE.Exp e,e1,e1_1,e1_2;
      
            // do nothing if try to collate when codition expression
      
            case (e as DAE.MATRIX(matrix=((DAE.CREF())::_)::_), (DAE.STMT_WHEN(), _))
      
              then (e,inTpl);
      
            case (e as DAE.MATRIX(matrix=(((DAE.UNARY(exp = DAE.CREF())))::_)::_), (DAE.STMT_WHEN(), _))
      
              then (e,inTpl);
      
            case (e as DAE.ARRAY(array=(DAE.CREF())::_), (DAE.STMT_WHEN(), _))
      
              then (e,inTpl);
      
            case (e as DAE.ARRAY(array=(DAE.UNARY(exp = DAE.CREF()))::_), (DAE.STMT_WHEN(), _))
      
              then (e,inTpl);
      
             // collate in other cases
      
            case (e as DAE.MATRIX(matrix=((e1 as DAE.CREF())::_)::_), _)
      
              algorithm
      
        4
                e1_1 := Expression.expStripLastSubs(e1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.

        4
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.

        4
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,inTpl);
      
            case (e as DAE.MATRIX(matrix=(((e1 as DAE.UNARY(exp = DAE.CREF())))::_)::_), _)
      
              algorithm
      
        ✗
                e1_1 := Expression.expStripLastSubs(e1);
      
        ✗
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
        ✗
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,inTpl);
      
            case (e as DAE.ARRAY(array=(e1 as DAE.CREF())::_), _)
      
              algorithm
      
        94
                e1_1 := Expression.expStripLastSubs(e1);
      
          2/2✓ Branch 1 taken 29 times.
✓ Branch 2 taken 65 times.

        98
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
          2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 61 times.

        65
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,inTpl);
      
            case (e as DAE.ARRAY(array=(e1 as DAE.UNARY(exp = DAE.CREF()))::_), _)
      
              algorithm
      
        ✗
                e1_1 := Expression.expStripLastSubs(e1);
      
        ✗
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
        ✗
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,inTpl);
      
            else (inExp,inTpl);
      
          end matchcontinue;
      
        end traversingcollateArrExpStmt;
      
        public function collateArrExpList
      
        " author Frenkel TUD:
      
          replace {a[1],a[2],a[3]} for Real a[3] with a"
      
          input list<DAE.Exp> iexpl;
      
          input Option<AvlTreePathFunction.Tree> optfunc;
      
          output list<DAE.Exp> outexpl;
      
        algorithm
      
          outexpl := match iexpl
      
            local
      
              DAE.Exp e,e1;
      
              list<DAE.Exp> expl1,expl;
      
            case {} then {};
      
            case e::expl algorithm
      
        ✗
              (e1,_) := collateArrExp(e,optfunc);
      
        ✗
              expl1 := collateArrExpList(expl,optfunc);
      
            then
      
              e1::expl1;
      
          end match;
      
        end collateArrExpList;
      
        public function collateArrExp "
      
        Author: Frenkel TUD 2010-07"
      
          input DAE.Exp inExp;
      
          input Option<AvlTreePathFunction.Tree> inFuncs;
      
          output DAE.Exp outExp;
      
          output Option<AvlTreePathFunction.Tree> outFuncs;
      
        algorithm
      
        846
          (outExp,outFuncs) := Expression.traverseExpBottomUp(inExp, traversingcollateArrExp, inFuncs);
      
        end collateArrExp;
      
        protected function traversingcollateArrExp
      
          input DAE.Exp inExp;
      
          input Option<AvlTreePathFunction.Tree> inFuncs;
      
          output DAE.Exp outExp;
      
          output Option<AvlTreePathFunction.Tree> funcs;
      
        algorithm
      
          (outExp,funcs) := matchcontinue (inExp,inFuncs)
      
            local
      
              DAE.Exp e,e1,e1_1,e1_2;
      
            case (e as DAE.MATRIX(matrix=((e1 as DAE.CREF())::_)::_),funcs)
      
              algorithm
      
        4
                e1_1 := Expression.expStripLastSubs(e1);
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.

        6
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
          1/2✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.

        2
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,funcs);
      
            case (e as DAE.MATRIX(matrix=(((e1 as DAE.UNARY(exp = DAE.CREF())))::_)::_),funcs)
      
              algorithm
      
        ✗
                e1_1 := Expression.expStripLastSubs(e1);
      
        ✗
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
        ✗
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,funcs);
      
            case (e as DAE.ARRAY(array=(e1 as DAE.CREF())::_),funcs)
      
              algorithm
      
        8
                e1_1 := Expression.expStripLastSubs(e1);
      
          2/2✓ Branch 1 taken 5 times.
✓ Branch 2 taken 3 times.

        11
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
          1/2✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.

        3
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,funcs);
      
            case (e as DAE.ARRAY(array=(e1 as DAE.UNARY(exp = DAE.CREF()))::_),funcs)
      
              algorithm
      
        4
                e1_1 := Expression.expStripLastSubs(e1);
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 3 times.

        7
                (e1_2,true) := Expression.extendArrExp(e1_1,false);
      
          1/2✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.

        3
                true := ExpressionBasics.expEqual(e,e1_2);
      
              then (e1_1,funcs);
      
            else (inExp,inFuncs);
      
          end matchcontinue;
      
        end traversingcollateArrExp;
      
        public function getEquationBlock"author: PA
      
          Returns the block the equation belongs to.
      
        "
      
          input Integer inInteger;
      
          input BackendDAE.StrongComponents inComps;
      
          output BackendDAE.StrongComponent outComp;
      
        algorithm
      
          outComp:=
      
          matchcontinue (inInteger,inComps)
      
            local
      
              Integer i;
      
              list<Integer> elst;
      
              BackendDAE.StrongComponents comps;
      
              BackendDAE.StrongComponent comp;
      
            case (i,comp::_)
      
              algorithm
      
        ✗
                (elst,_) := BackendDAETransform.getEquationAndSolvedVarIndxes(comp);
      
        ✗
                true := listMember(i,elst);
      
              then
      
                comp;
      
            case (i,_::comps)
      
              algorithm
      
        ✗
                comp := getEquationBlock(i,comps);
      
              then
      
                comp;
      
          end matchcontinue;
      
        end getEquationBlock;
      
        /******************************************************************
      
         stuff to calculate adjacency matrix
      
         wbraun: It should be renames to Adjacency matrix, because
      
            adjacency matrix descibes the relation between knots and edges.
      
            In the sense it is used here is the relation between knots and
      
            knots of a bigraph.
      
        ******************************************************************/
      
        public function adjacencyMatrix
      
        "author: PA, adrpo
      
          Calculates the adjacency matrix, i.e. which variables are present in each equation.
      
          You can ask for absolute indexes or normal (negative for der) via the IndexType.
      
            wbraun: beware dim(AdjacencyMatrix) != dim(AdjacencyMatrixT) due to array equations. "
      
          input BackendDAE.EqSystem inEqSystem;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqns;
      
        algorithm
      
          try
      
        103159
            BackendDAE.EQSYSTEM(orderedVars = vars, orderedEqs = eqns) := inEqSystem;
      
        103159
            (outAdjacencyMatrix, outAdjacencyMatrixT) :=
      
              adjacencyMatrixDispatch(vars, eqns, inIndexType, functionTree, isInitial);
      
          else
      
        ✗
            Error.addMessage(Error.INTERNAL_ERROR, {"BackendDAEUtil.adjacencyMatrix failed."});
      
        ✗
            fail();
      
          end try;
      
        end adjacencyMatrix;
      
        public function adjacencyMatrixMasked
      
          input BackendDAE.EqSystem inEqSystem;
      
          input BackendDAE.IndexType inIndexType;
      
          input array<Boolean> inMask;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqns;
      
        algorithm
      
          try
      
        46
            BackendDAE.EQSYSTEM(orderedVars = vars, orderedEqs = eqns) := inEqSystem;
      
        46
            (outAdjacencyMatrix, outAdjacencyMatrixT) :=
      
              adjacencyMatrixDispatchMasked(vars, eqns, inIndexType, inMask, functionTree, isInitial);
      
          else
      
        ✗
            Error.addMessage(Error.INTERNAL_ERROR, {"BackendDAEUtil.adjacencyMatrix failed."});
      
        ✗
            fail();
      
          end try;
      
        end adjacencyMatrixMasked;
      
        public function adjacencyMatrixScalar
      
        "author: PA, adrpo
      
          Calculates the adjacency matrix, i.e. which variables are present in each equation.
      
          You can ask for absolute indexes or normal (negative for der) via the IndexType"
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
          output array<list<Integer>> outMapEqnIncRow;
      
          output array<Integer> outMapIncRowEqn;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqns;
      
        algorithm
      
          try
      
        223221
            BackendDAE.EQSYSTEM(orderedVars = vars, orderedEqs = eqns) := syst;
      
        223221
            ExpandableArray.compress(eqns);
      
        223221
            (outAdjacencyMatrix, outAdjacencyMatrixT, outMapEqnIncRow, outMapIncRowEqn) :=
      
              adjacencyMatrixDispatchScalar(vars, eqns, inIndexType, functionTree, isInitial);
      
          else
      
        ✗
            Error.addMessage(Error.INTERNAL_ERROR, {"BackendDAEUtil.adjacencyMatrixScalar failed."});
      
        ✗
            fail();
      
          end try;
      
        end adjacencyMatrixScalar;
      
        public function uniqueRow
      
          "The row's variable indices without duplicates, in the descending order
      
           AvlSetInt.listKeys listed them in when the row was a set."
      
          input list<Integer> row;
      
          output list<Integer> outRow;
      
        algorithm
      
        3139682
          outRow := List.sortedUnique(List.sort(row, intLt), intEq);
      
        end uniqueRow;
      
        public function getIndexType
      
        "author kabdelhak FHB 10-2019
      
         Returns the index type of the current adjacency matrix and two Booleans:
      
         Boolean 1: true, if is scalar.
      
         Boolean 2: true, if analytical to structural singularity processing has already been done.
      
         Fails if none are present."
      
          input BackendDAE.EqSystem syst;
      
          output BackendDAE.IndexType indexType;
      
          output Boolean scalar;
      
          output Boolean processed;
      
        algorithm
      
          3/6✗ Branch 0 not taken.
✓ Branch 1 taken 119015 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 119015 times.
✓ Branch 5 taken 119015 times.
✗ Branch 6 not taken.

        119015
          SOME((_, _, indexType, scalar, processed)) := syst.mapping;
      
        end getIndexType;
      
        public function hasIndexTypeSolvableAndUnprocessedScalar
      
        "author kabdelhak FHB 10-2019
      
         Returns true if the equation system has an adjacency matrix that got
      
         computed by strict solvability rules and wasn't already analyzed
      
         by the analytical to structural conversion algorithm."
      
          input BackendDAE.EqSystem syst;
      
          output Boolean b = false;
      
        protected
      
          BackendDAE.IndexType indexType;
      
          Boolean scalar, processed;
      
        algorithm
      
          try
      
        119015
            (indexType, scalar, processed) := getIndexType(syst);
      
            b := match (indexType, scalar, processed)
      
              case (BackendDAE.SOLVABLE(), true, false) then true;
      
              else false;
      
            end match;
      
          else
      
            /* no mapping available, return false */
      
          end try;
      
        end hasIndexTypeSolvableAndUnprocessedScalar;
      
        public function hasScalarAdjacencyMatrix
      
        "author kabdelhak FHB 10-2019
      
         Returns true if the equation system has a scalar adjacency matrix."
      
          input BackendDAE.EqSystem syst;
      
          output Boolean b;
      
        algorithm
      
        ✗
          (_, b, _) := getIndexType(syst);
      
        end hasScalarAdjacencyMatrix;
      
        public function setAnalyticalToStructuralProcessed
      
          input output BackendDAE.EqSystem syst;
      
          input Boolean processed;
      
        protected
      
          array<list<Integer>> mapArrayToScalar;
      
          array<Integer> mapScalarToArray;
      
          BackendDAE.IndexType indexType;
      
          Boolean scalar;
      
        algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1510 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1510 times.

        1510
          SOME((mapArrayToScalar, mapScalarToArray, indexType, scalar, _)) := syst.mapping;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1510 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1510 times.

        3020
          syst.mapping := SOME((mapArrayToScalar, mapScalarToArray, indexType, scalar, processed));
      
        end setAnalyticalToStructuralProcessed;
      
        public function adjacencyMatrixDispatch
      
        "@author: adrpo
      
          Calculates the adjacency matrix as an array of list of integers"
      
          input BackendDAE.Variables inVars;
      
          input BackendDAE.EquationArray inEqns;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree = NONE();
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyArray;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyArrayT;
      
        protected
      
          Integer num_eqs, num_vars;
      
          BackendDAE.Equation eq;
      
          list<Integer> row;
      
          list<Integer> rowLst;
      
        algorithm
      
        108254
          num_eqs := BackendEquation.getNumberOfEquations(inEqns);
      
        108254
          num_vars := BackendVariable.varsSize(inVars);
      
        108254
          outAdjacencyArray := arrayCreate(num_eqs, {});
      
        108254
          outAdjacencyArrayT := arrayCreate(num_vars, {});
      
          2/2✓ Branch 0 taken 6384 times.
✓ Branch 1 taken 101870 times.

        1767501
          for idx in 1:num_eqs loop
      
            // Get the equation.
      
        1659247
            eq := BackendEquation.get(inEqns, idx);
      
            // Compute the row.
      
        1659247
            rowLst := adjacencyRow(eq, inVars, inIndexType, functionTree, {}, isInitial);
      
        1659247
            row := uniqueRow(rowLst);
      
            // Put it in the arrays.
      
        1659247
            arrayUpdate(outAdjacencyArray, idx, row);
      
        1659247
            outAdjacencyArrayT := filladjacencyMatrixT(row, {idx}, outAdjacencyArrayT);
      
          end for;
      
        end adjacencyMatrixDispatch;
      
        public function adjacencyMatrixDispatchMasked
      
          input BackendDAE.Variables inVars;
      
          input BackendDAE.EquationArray inEqns;
      
          input BackendDAE.IndexType inIndexType;
      
          input array<Boolean> inMask;
      
          input Option<AvlTreePathFunction.Tree> functionTree = NONE();
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyArray;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyArrayT;
      
        protected
      
          Integer num_eqs, num_vars;
      
          BackendDAE.Equation eq;
      
          list<Integer> row;
      
          list<Integer> rowLst;
      
        algorithm
      
        46
          num_eqs := BackendEquation.getNumberOfEquations(inEqns);
      
        46
          num_vars := BackendVariable.varsSize(inVars);
      
        46
          outAdjacencyArray := arrayCreate(num_eqs, {});
      
        46
          outAdjacencyArrayT := arrayCreate(num_vars, {});
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.

        743
          for idx in 1:num_eqs loop
      
          2/2✓ Branch 1 taken 525 times.
✓ Branch 2 taken 172 times.

        697
            if inMask[idx] then
      
              // Get the equation.
      
        525
              eq := BackendEquation.get(inEqns, idx);
      
              // Compute the row.
      
        525
              rowLst := adjacencyRow(eq, inVars, inIndexType, functionTree, {}, isInitial);
      
        525
              row := uniqueRow(rowLst);
      
              // Put it in the arrays.
      
        525
              arrayUpdate(outAdjacencyArray, idx, row);
      
        525
              outAdjacencyArrayT := filladjacencyMatrixT(row, {idx}, outAdjacencyArrayT);
      
            end if;
      
          end for;
      
        end adjacencyMatrixDispatchMasked;
      
        protected function adjacencyMatrixDispatchScalar
      
        "@author: adrpo
      
          Calculates the adjacency matrix as an array of list of integers"
      
          input BackendDAE.Variables inVars;
      
          input BackendDAE.EquationArray inEqns;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyArray;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyArrayT = outAdjacencyArrayT;
      
          output array<list<Integer>> omapEqnIncRow;
      
          output array<Integer> omapIncRowEqn;
      
        protected
      
          Integer num_eqs, num_vars, size, num_rows = 0;
      
          BackendDAE.Equation eq;
      
          list<Integer> rowLst;
      
          list<Integer> row, row_indices, imap = {};
      
          list<BackendDAE.AdjacencyMatrixElement> iarr = {};
      
        algorithm
      
        223221
          num_eqs := BackendEquation.getNumberOfEquations(inEqns);
      
        223221
          num_vars := BackendVariable.varsSize(inVars);
      
        223221
          outAdjacencyArrayT := arrayCreate(num_vars, {});
      
        223221
          omapEqnIncRow := arrayCreate(num_eqs, {});
      
          2/2✓ Branch 0 taken 174951 times.
✓ Branch 1 taken 48270 times.

        1450306
          for idx in 1:num_eqs loop
      
            // Get the equation.
      
        1227085
            eq := BackendEquation.get(inEqns, idx);
      
            // Compute the row.
      
        1227085
            (rowLst, size) := adjacencyRow(eq, inVars, inIndexType, functionTree, {}, isInitial);
      
        1227085
            row := uniqueRow(rowLst);
      
        1227085
            row_indices := List.intRange2(num_rows + 1, num_rows + size);
      
        1227085
            num_rows := num_rows + size;
      
        1227085
            arrayUpdate(omapEqnIncRow, idx, row_indices);
      
        1227085
            imap := List.consN(size, idx, imap);
      
            // Put it in the arrays
      
        1227085
            iarr := List.consN(size, row, iarr);
      
        1227085
            outAdjacencyArrayT := filladjacencyMatrixT(row, row_indices, outAdjacencyArrayT);
      
          end for;
      
        223221
          outAdjacencyArray := List.listArrayReverse(iarr);
      
        223221
          omapIncRowEqn := List.listArrayReverse(imap);
      
        end adjacencyMatrixDispatchScalar;
      
        protected function filladjacencyMatrixT
      
        "@author: Frenkel TUD 2011-04
      
          inserts the equation numbers"
      
          input BackendDAE.AdjacencyMatrixElement eqns;
      
          input list<Integer> eqnsindxs;
      
          input BackendDAE.AdjacencyMatrixT inAdjacencyArrayT;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyArrayT = inAdjacencyArrayT;
      
        protected
      
          BackendDAE.AdjacencyMatrixElement row;
      
          list<Integer> ei, eqnsindxsNeg;
      
        algorithm
      
          4/4✓ Branch 0 taken 3006360 times.
✓ Branch 1 taken 2886857 times.
✓ Branch 2 taken 3006360 times.
✓ Branch 3 taken 2886857 times.

        5893217
          eqnsindxsNeg := list(intNeg(e) for e in eqnsindxs);
      
          2/2✓ Branch 0 taken 7909625 times.
✓ Branch 1 taken 2886857 times.

        10796482
          for v in eqns loop
      
          2/2✓ Branch 0 taken 304405 times.
✓ Branch 1 taken 7605220 times.

        7909625
            if v < 0 then
      
        304405
              v := intAbs(v);
      
              ei := eqnsindxsNeg;
      
            else
      
              ei := eqnsindxs;
      
            end if;
      
            // Put it in the array.
      
        7909625
            row := listAppend(ei, arrayGet(inAdjacencyArrayT, v));
      
        7909625
            arrayUpdate(outAdjacencyArrayT, v, row);
      
          end for;
      
        end filladjacencyMatrixT;
      
        public function adjacencyRow
      
        "author: PA
      
          Helper function to adjacencyMatrix. Calculates the indidence row
      
          in the matrix for one equation."
      
          input BackendDAE.Equation inEquation;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> iRow;
      
          input Boolean isInitial;
      
          output list<Integer> outIntegerLst;
      
          output Integer rowSize;
      
        protected
      
          list<Integer> whenIntegerLst;
      
          BackendDAE.Equation inlinedEquation;
      
        algorithm
      
          whenIntegerLst := matchcontinue inIndexType
      
            local
      
              BackendDAE.EquationKind kind;
      
              DAE.ComponentRef cr;
      
              Integer i;
      
              list<Integer> varIxs;
      
            case BackendDAE.BASECLOCK_IDX()
      
              algorithm
      
        172462
                BackendDAE.EQUATION_ATTRIBUTES(kind = kind) := BackendEquation.getEquationAttributes(inEquation);
      
          2/2✓ Branch 0 taken 172395 times.
✓ Branch 1 taken 67 times.

        172462
                BackendDAE.CLOCKED_EQUATION(i) := kind;
      
        67
                cr := DAE.CREF_IDENT(BackendDAE.WHENCLK_PRREFIX + intString(i), DAE.T_CLOCK_DEFAULT, {});
      
        67
                (_, varIxs) := BackendVariable.getVar(cr, vars);
      
        67
              then varIxs;
      
            case BackendDAE.SUBCLOCK_IDX()
      
              algorithm
      
        1230
                BackendDAE.EQUATION_ATTRIBUTES(kind = kind) := BackendEquation.getEquationAttributes(inEquation);
      
          2/2✓ Branch 0 taken 976 times.
✓ Branch 1 taken 254 times.

        1230
                BackendDAE.CLOCKED_EQUATION(i) := kind;
      
        254
                cr := DAE.CREF_IDENT(BackendDAE.WHENCLK_PRREFIX + intString(i), DAE.T_CLOCK_DEFAULT, {});
      
        254
                (_, varIxs) := BackendVariable.getVar(cr, vars);
      
        195
              then varIxs;
      
            else {};
      
          end matchcontinue;
      
          /* Fix for ticket #5170
      
          Functions with the annotation "InlineAfterIndexReduction" can contain dependencies which are only
      
          used for differentiation purposes and should not be part of the adjacency matrix. Therefore these
      
          are inlined before constructing the adjacency row.
      
          E.g. func(a,b) = a --d/dt--> func_der(a,b) = b
      
          */
      
        2918505
          (inlinedEquation,_) := BackendInline.inlineEq(inEquation,(functionTree,{DAE.AFTER_INDEX_RED_INLINE()}));
      
          (outIntegerLst,rowSize) := matchcontinue inlinedEquation
      
            local
      
              list<Integer> lst1,res;
      
              list<Integer> dimsize;
      
              DAE.Exp e1,e2,e,expCref;
      
              list<DAE.Exp> expl;
      
              DAE.ComponentRef cr;
      
              BackendDAE.WhenEquation we;
      
              Integer size;
      
              String eqnstr, str;
      
              list<DAE.Statement> statementLst;
      
              list<list<BackendDAE.Equation>> eqnslst;
      
              list<BackendDAE.Equation> eqns;
      
              BackendDAE.Equation eqn;
      
              list<DAE.ComponentRef> crefLst;
      
              list<BackendDAE.Var> varslst;
      
              list<Integer> p;
      
            // EQUATION
      
            case BackendDAE.EQUATION(exp = e1,scalar = e2)
      
              algorithm
      
        2789316
                lst1 := adjacencyRowExp(e1, vars, iRow, functionTree, inIndexType, isInitial);
      
        2789316
                res := adjacencyRowExp(e2, vars, lst1, functionTree, inIndexType, isInitial);
      
        2789316
              then
      
                (res,1);
      
            // COMPLEX_EQUATION
      
            case BackendDAE.COMPLEX_EQUATION(size=size,left=e1,right=e2)
      
              algorithm
      
        19524
                lst1 := adjacencyRowExp(e1, vars, iRow, functionTree, inIndexType, isInitial);
      
        19524
                res := adjacencyRowExp(e2, vars, lst1, functionTree, inIndexType, isInitial);
      
        19524
              then
      
                (res,size);
      
            // ARRAY_EQUATION
      
            case BackendDAE.ARRAY_EQUATION(dimSize=dimsize,left=e1,right=e2)
      
              algorithm
      
          2/2✓ Branch 1 taken 21335 times.
✓ Branch 2 taken 238 times.

        21573
                size := if Flags.isSet(Flags.NF_SCALARIZE) then List.reduce(dimsize, intMul) else 1;
      
        21573
                lst1 := adjacencyRowExp(e1, vars, iRow, functionTree, inIndexType, isInitial);
      
        21573
                res := adjacencyRowExp(e2, vars, lst1, functionTree, inIndexType, isInitial);
      
        21573
              then
      
                (res,size);
      
            // FOR_EQUATION
      
            case BackendDAE.FOR_EQUATION(body = eqn, iter = DAE.CREF(componentRef = DAE.CREF_IDENT(ident = str)))
      
              algorithm
      
                // assume one equation defining a whole array var (no NF_SCALARIZE)
      
        209
                eqn := BackendEquation.traverseExpsOfEquation(eqn, function Expression.traverseExpTopDown(func = stripIterSub), str);
      
        209
              then
      
                adjacencyRow(eqn, vars, inIndexType, functionTree, iRow, isInitial);
      
            // SOLVED_EQUATION
      
            case BackendDAE.SOLVED_EQUATION(componentRef = cr,exp = e)
      
              algorithm
      
        71751
                expCref := Expression.crefExp(cr);
      
        71751
                lst1 := adjacencyRowExp(expCref, vars, iRow, functionTree, inIndexType, isInitial);
      
        71751
                res := adjacencyRowExp(e, vars, lst1, functionTree, inIndexType, isInitial);
      
        71751
              then
      
                (res,1);
      
            // RESIDUAL_EQUATION
      
            case BackendDAE.RESIDUAL_EQUATION(exp = e)
      
              algorithm
      
        ✗
                res := adjacencyRowExp(e, vars, iRow, functionTree, inIndexType, isInitial);
      
        ✗
              then
      
                (res,1);
      
            // WHEN_EQUATION
      
            case BackendDAE.WHEN_EQUATION(size=size,whenEquation = we)
      
              algorithm
      
        7416
                res := adjacencyRowWhen(we, vars, inIndexType, functionTree, iRow, isInitial);
      
        7416
              then
      
                (res,size);
      
            // ALGORITHM
      
            case BackendDAE.ALGORITHM(size=size,alg=DAE.ALGORITHM_STMTS(statementLst = statementLst))
      
              algorithm
      
          2/2✓ Branch 0 taken 5789 times.
✓ Branch 1 taken 2925 times.

        14503
                res := traverseStmts(statementLst, function adjacencyRowAlgorithm(inVariables = vars,
      
                    functionTree = functionTree, inIndexType = inIndexType, isInitial = isInitial), iRow);
      
                /*
      
                  If looking for solvability add all discrete output variables, even if they don't occur in the algorithm.
      
                  Discrete output variables that do not occur get computed by pre().
      
                  Ticket #5659
      
                */
      
        8714
                crefLst := CheckModel.algorithmStatementListOutputs(statementLst, DAE.EXPAND()); // expand as we're in an algorithm
      
          2/2✓ Branch 0 taken 24820 times.
✓ Branch 1 taken 8714 times.

        33534
                for cr in crefLst loop
      
                  try
      
        24820
                    (varslst, p) := BackendVariable.getVar(cr, vars);
      
        24251
                    res := adjacencyRowExp1DiscreteOrArray(varslst, p, res);
      
                  else
      
                    /* Nothing to do, BackendVariable.getVar fails for $START, $PRE, time etc. */
      
                  end try;
      
          2/2✓ Branch 0 taken 654 times.
✓ Branch 1 taken 24166 times.

        24820
                  if vars.hasStartVars then
      
                    try
      
        654
                      (varslst, p) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        ✗
                      res := adjacencyRowExp1DiscreteOrArray(varslst, p, res);
      
                    else
      
                      /* Nothing to do, BackendVariable.getVar fails for $START, $PRE, time etc. */
      
                    end try;
      
                  end if;
      
                end for;
      
        8714
              then
      
                (res,size);
      
            /*
      
              special case: initial()
      
              if initial() then ... else ... end if;
      
              only then branch needs to be checked for initialization and else branch otherwise
      
            */
      
            case BackendDAE.IF_EQUATION(conditions={DAE.CALL(path=Absyn.IDENT("initial"))},eqnstrue=eqnslst,eqnsfalse=eqns)
      
              algorithm
      
        ✗
                if not isInitial then
      
                  // only one condition, therefore the list of lists for "then" only contains one list
      
        ✗
                  {eqns} := eqnslst;
      
                end if;
      
        ✗
                (res,size) := adjacencyRowLst(eqns, vars, inIndexType, functionTree, iRow, isInitial);
      
              then
      
                (res,size);
      
            /*
      
              special case: NEGATED initial()
      
              if not initial() then ... else ... end if;
      
              only else branch needs to be checked for initialization and then branch otherwise
      
            */
      
            case BackendDAE.IF_EQUATION(conditions={DAE.LUNARY(DAE.NOT(), DAE.CALL(path=Absyn.IDENT("initial")))},eqnstrue=eqnslst,eqnsfalse=eqns)
      
              algorithm
      
        ✗
                if isInitial then
      
                  // only one condition, therefore the list of lists for "then" only contains one list
      
        ✗
                  {eqns} := eqnslst;
      
                end if;
      
        ✗
                (res,size) := adjacencyRowLst(eqns, vars, inIndexType, functionTree, iRow, isInitial);
      
              then
      
                (res,size);
      
            /*
      
              if Equation
      
              ToDo: More checks for stuff like initial()
      
            */
      
            case BackendDAE.IF_EQUATION(conditions=expl,eqnstrue=eqnslst,eqnsfalse=eqns)
      
              algorithm
      
          1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.

        4
                res := adjacencyRow1(expl, adjacencyRowExp, vars, iRow, functionTree, inIndexType, isInitial);
      
        2
                res := adjacencyRowLstLst(eqnslst, vars, inIndexType, functionTree, res, isInitial);
      
        2
                (res,size) := adjacencyRowLst(eqns, vars, inIndexType, functionTree, res, isInitial);
      
              then
      
                (res,size);
      
            else
      
              algorithm
      
        ✗
                eqnstr := BackendDump.equationString(inEquation);
      
        ✗
                str := "- BackendDAEUtil.adjacencyRow failed for equation: " + eqnstr;
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {str});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        2918505
          outIntegerLst := listAppend(whenIntegerLst, outIntegerLst);
      
        end adjacencyRow;
      
        protected
      
        function stripIterSub
      
        "Strips the last subscript if it is equal to given inIter ident.
      
         This enables incicence analysis for array variables defined in for loops.
      
         author: rfranke"
      
          input DAE.Exp inExp;
      
          input DAE.Ident inIter;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output DAE.Ident outIter = inIter;
      
        algorithm
      
          (outExp, cont) := match inExp
      
            local
      
              DAE.ComponentRef cr;
      
              DAE.Type ty;
      
            case DAE.CREF(componentRef = cr, ty = ty)
      
        526
            then (DAE.CREF(ComponentReference.crefStripIterSub(cr, inIter), ty), false);
      
            else (inExp, true);
      
          end match;
      
        end stripIterSub;
      
        protected function adjacencyRowLst
      
        "author: Frenkel TUD
      
          Helper function to adjacencyMatrix. Calculates the indidence row
      
          in the matrix for if equation."
      
          input list<BackendDAE.Equation> inEquation;
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inIntegerLst;
      
          input Boolean isInitial;
      
          output list<Integer> outIntegerLst = inIntegerLst;
      
          output Integer rowSize = 0;
      
        protected
      
          Integer size;
      
        algorithm
      
          2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 6 times.

        13
          for eq in inEquation loop
      
        7
            (outIntegerLst, size) :=
      
              adjacencyRow(eq, inVariables, inIndexType, functionTree, outIntegerLst, isInitial);
      
        7
            rowSize := rowSize + size;
      
          end for;
      
        end adjacencyRowLst;
      
        protected function adjacencyRowLstLst
      
        "author: Frenkel TUD
      
          Helper function to adjacencyMatrix. Calculates the indidence row
      
          in the matrix for if equation."
      
          input list<list<BackendDAE.Equation>> inEquation;
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inIntegerLst;
      
          input Boolean isInitial;
      
          output list<Integer> outIntegerLst = inIntegerLst;
      
          output Integer rowSize = 0;
      
        protected
      
          Integer size;
      
        algorithm
      
          2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.

        6
          for eql in inEquation loop
      
        4
            (outIntegerLst, size) := adjacencyRowLst(eql, inVariables, inIndexType,
      
                functionTree, outIntegerLst, isInitial);
      
        4
            rowSize := rowSize + size;
      
          end for;
      
        end adjacencyRowLstLst;
      
        protected function adjacencyRowWhen
      
        "Helper function to adjacencyMatrix. Calculates the indidence row
      
          in the matrix for a when equation."
      
          input BackendDAE.WhenEquation inEquation;
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inRow;
      
          input Boolean isInitial;
      
          output list<Integer> outRow;
      
        algorithm
      
          outRow := match inEquation
      
            local
      
              DAE.Exp cond;
      
              BackendDAE.WhenEquation elsewe;
      
              Option<BackendDAE.WhenEquation> oelsewe;
      
              list<BackendDAE.WhenOperator> whenStmtLst;
      
            case BackendDAE.WHEN_STMTS(condition = cond, whenStmtLst = whenStmtLst, elsewhenPart = oelsewe)
      
              algorithm
      
        7557
                outRow := adjacencyRowExp(cond, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        7557
                outRow := adjacencyRowWhenOps(whenStmtLst, inVariables, inIndexType, functionTree, outRow, isInitial);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 7557 times.
✓ Branch 2 taken 141 times.
✓ Branch 3 taken 7416 times.

        7557
                if isSome(oelsewe) then
      
        141
                  SOME(elsewe) := oelsewe;
      
                  outRow := adjacencyRowWhen(elsewe, inVariables, inIndexType, functionTree, outRow, isInitial);
      
                end if;
      
            then outRow;
      
          end match;
      
        end adjacencyRowWhen;
      
        protected function adjacencyRowWhenOps
      
        "Helper function to adjacencyMatrix. Calculates the indidence row
      
          in the matrix for a when equation stmts."
      
          input list<BackendDAE.WhenOperator>  inWhenOps;
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.IndexType inIndexType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inRow;
      
          input Boolean isInitial;
      
          output list<Integer> outRow;
      
        algorithm
      
          outRow := match inWhenOps
      
            local
      
              DAE.Exp e1, e2;
      
              DAE.ComponentRef cr;
      
              list<BackendDAE.WhenOperator> rest;
      
            case {} then inRow;
      
            case BackendDAE.ASSIGN(left = DAE.CREF(componentRef = DAE.WILD()), right = e2)::rest
      
              algorithm
      
        ✗
                outRow := adjacencyRowExp(e2, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        ✗
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
            case BackendDAE.ASSIGN(left = e1, right = e2)::rest
      
              algorithm
      
                //e1 = Expression.crefExp(cr);
      
        7441
                outRow := adjacencyRowExp(e1, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        7441
                outRow := adjacencyRowExp(e2, inVariables, outRow, functionTree, inIndexType, isInitial);
      
        7441
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
            case BackendDAE.REINIT(stateVar = cr, value = e2)::rest
      
              algorithm
      
        72
                e1 := Expression.crefExp(cr);
      
        72
                outRow := adjacencyRowExp(e1, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        72
                outRow := adjacencyRowExp(e2, inVariables, outRow, functionTree, inIndexType, isInitial);
      
        72
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
            case BackendDAE.ASSERT(condition = e1, message = e2)::rest
      
              algorithm
      
        14
                outRow := adjacencyRowExp(e1, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        14
                outRow := adjacencyRowExp(e2, inVariables, outRow, functionTree, inIndexType, isInitial);
      
        14
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
            case BackendDAE.TERMINATE(message = e1)::rest
      
              algorithm
      
        14
                outRow := adjacencyRowExp(e1, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        14
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
            case BackendDAE.NORETCALL(exp = e1)::rest
      
              algorithm
      
        16
                outRow := adjacencyRowExp(e1, inVariables, inRow, functionTree, inIndexType, isInitial);
      
        16
                outRow := adjacencyRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow, isInitial);
      
            then outRow;
      
          end match;
      
        end adjacencyRowWhenOps;
      
        protected function adjacencyRowAlgorithm
      
          input DAE.Exp exp;
      
          input output list<Integer> row;
      
          input BackendDAE.Variables inVariables;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input BackendDAE.IndexType inIndexType;
      
          input Boolean isInitial;
      
        algorithm
      
        85572
          row := adjacencyRowExp(exp, inVariables, row, functionTree, inIndexType, isInitial);
      
        end adjacencyRowAlgorithm;
      
        public function adjacencyRow1
      
          "Tail recursive implementation."
      
          input list<Type_a> inList;
      
          input FuncType inFunc;
      
          input Type_b inArg;
      
          input Type_c inArg1;
      
          input Type_d inArg2;
      
          input Type_e inArg3;
      
          input Type_f inArg4;
      
          output Type_c outArg1;
      
          replaceable type Type_a subtypeof Any;
      
          replaceable type Type_b subtypeof Any;
      
          replaceable type Type_c subtypeof Any;
      
          replaceable type Type_d subtypeof Any;
      
          replaceable type Type_e subtypeof Any;
      
          replaceable type Type_f subtypeof Any;
      
          partial function FuncType
      
            input Type_a inElem;
      
            input Type_b inArg;
      
            input Type_c inArg1;
      
            input Type_d inArg2;
      
            input Type_e inArg3;
      
            input Type_f inArg4;
      
            output Type_c outArg1;
      
          end FuncType;
      
        algorithm
      
          outArg1 := match inList
      
            local
      
              Type_a e1;
      
              list<Type_a> rest_e1;
      
              Type_c res,res1;
      
            case {} then inArg1;
      
            case e1::rest_e1
      
              algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
                res := inFunc(e1, inArg, inArg1, inArg2, inArg3, inArg4);
      
        4
                res1 := adjacencyRow1(rest_e1, inFunc, inArg, res, inArg2, inArg3, inArg4);
      
              then
      
                res1;
      
          end match;
      
        end adjacencyRow1;
      
        public function adjacencyRowExp "author: PA
      
          Helper function to adjacencyRow, investigates expressions for variables,
      
          returning variable indexes."
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVariables;
      
          input list<Integer> inIntegerLst;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input BackendDAE.IndexType inIndexType;
      
          input Boolean isInitial;
      
          output list<Integer> outIntegerLst;
      
        algorithm
      
          outIntegerLst := match inIndexType
      
            local
      
              list<Integer> vallst, outLst;
      
              Integer key;
      
            case BackendDAE.SPARSE() algorithm
      
          2/2✓ Branch 0 taken 251035 times.
✓ Branch 1 taken 14240 times.

        516310
              (_, (_, vallst, _)) := Expression.traverseExpTopDown(inExp, traversingadjacencyRowExpFinderwithInput, (inVariables, inIntegerLst, isInitial));
      
            then vallst;
      
            case BackendDAE.SOLVABLE() algorithm
      
          2/2✓ Branch 0 taken 809942 times.
✓ Branch 1 taken 655965 times.

        2275849
              (_, (vallst, _)) := Expression.traverseExpTopDown(inExp, function traversingadjacencyRowExpSolvableFinder(vars = inVariables, isInitial = isInitial, ofunctionTree = functionTree), (inIntegerLst, AvlSetPath.EMPTY()));
      
            then vallst;
      
            case BackendDAE.BASECLOCK_IDX() algorithm
      
          1/2✓ Branch 0 taken 349671 times.
✗ Branch 1 not taken.

        699342
              (_, (_, vallst, _)) := Expression.traverseExpTopDown(inExp, traversingAdjacencyRowExpFinderBaseClock, (inVariables, inIntegerLst, isInitial));
      
            then vallst;
      
            case BackendDAE.SUBCLOCK_IDX() algorithm
      
          1/2✓ Branch 0 taken 2444 times.
✗ Branch 1 not taken.

        4888
              (_, (_, vallst, _)) := Expression.traverseExpTopDown(inExp, traversingAdjacencyRowExpFinderSubClock, (inVariables, inIntegerLst, isInitial));
      
            then vallst;
      
            // The row is absolute already; only what this expression adds needs intAbs.
      
            case BackendDAE.ABSOLUTE() algorithm
      
          2/2✓ Branch 0 taken 544316 times.
✓ Branch 1 taken 303321 times.

        1391953
              (_, vallst) := Expression.traverseExpTopDown(inExp, function traversingadjacencyRowExpFinder(vars = inVariables, isInitial = isInitial), {});
      
              outLst := inIntegerLst;
      
          2/2✓ Branch 1 taken 1503800 times.
✓ Branch 2 taken 847637 times.

        2351437
              for key in listReverse(vallst) loop
      
        1503800
                outLst := intAbs(key) :: outLst;
      
              end for;
      
            then outLst;
      
            else algorithm
      
          2/2✓ Branch 0 taken 2254831 times.
✓ Branch 1 taken 816180 times.

        5325842
              (_, vallst) := Expression.traverseExpTopDown(inExp, function traversingadjacencyRowExpFinder(vars = inVariables, isInitial = isInitial), inIntegerLst);
      
        3071011
            then vallst;
      
          end match;
      
        end adjacencyRowExp;
      
        public function traversingadjacencyRowExpSolvableFinder "Helper for statesAndVarsExp.
      
          Bind vars, isInitial and ofunctionTree by partial application; only the row
      
          and the visited paths are threaded through the traversal."
      
          input DAE.Exp inExp;
      
          input tuple<list<Integer>, AvlSetPath.Tree> inTpl;
      
          input BackendDAE.Variables vars;
      
          input Boolean isInitial;
      
          input Option<AvlTreePathFunction.Tree> ofunctionTree;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<list<Integer>, AvlSetPath.Tree> outTpl;
      
        algorithm
      
          (outExp, cont, outTpl) := match (inExp, inTpl)
      
            local
      
              list<Integer> p, p2;
      
              list<Integer> pa;
      
              DAE.ComponentRef cr;
      
              DAE.Exp e, e1, e2;
      
              list<BackendDAE.Var> varslst;
      
              Boolean b, b1, b2;
      
              list<DAE.Exp> explst;
      
              Integer i;
      
              list<DAE.ComponentRef> crlst;
      
              tuple<list<Integer>, AvlSetPath.Tree> tpl;
      
              Integer diffindx;
      
              list<DAE.Subscript> subs;
      
              AvlSetPath.Tree visitedPaths;
      
              String idn;
      
            case (DAE.LBINARY(), tpl)
      
        4165
            then (inExp, false, tpl);
      
            case (DAE.RELATION(), tpl)
      
        3989
            then (inExp, false, tpl);
      
            case (DAE.IFEXP(), tpl)
      
              algorithm
      
                try
      
        61906
                  (e, b, tpl) := traversingadjacencyRowIfExpSolvableFinder(inExp, tpl, vars, isInitial, ofunctionTree);
      
                else
      
        ✗
                  (e, b, tpl) := (inExp, true, inTpl);
      
                end try;
      
        61906
            then (e, b, tpl);
      
            case (DAE.RANGE(), tpl)
      
        2116
            then (inExp, false, tpl);
      
            // a range subscript, else a constant index into the array expression
      
            case (DAE.ASUB(exp=e1, sub=subs), (pa, visitedPaths))
      
              algorithm
      
                try
      
          2/2✓ Branch 0 taken 1725 times.
✓ Branch 1 taken 10 times.

        1735
                  DAE.CREF(componentRef=cr) := e1;
      
        10
                  explst := List.map(subs, Expression.getSubscriptExp);
      
          2/6✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 10 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        10
                  {e2 as DAE.RANGE()} := ExpressionSimplify.simplifyList(explst);
      
        ✗
                  crlst := list(ComponentReference.subscriptCref(cr, {DAE.INDEX(e)}) for e in extendRange(e2, vars));
      
        ✗
                  (varslst, p) := BackendVariable.getVarLst(crlst, vars);
      
        ✗
                  pa := adjacencyRowExp1(varslst, p, pa, 0);
      
        ✗
                  tpl := (pa, visitedPaths);
      
        ✗
                  b := false;
      
                else
      
                  try
      
          5/8✗ Branch 0 not taken.
✓ Branch 1 taken 1735 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1735 times.
✓ Branch 4 taken 1317 times.
✓ Branch 5 taken 418 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 418 times.

        1735
                    {DAE.INDEX(DAE.ICONST(i))} := subs;
      
        418
                    e1 := Expression.nthArrayExp(e1, i);
      
          2/2✓ Branch 0 taken 337 times.
✓ Branch 1 taken 81 times.

        755
                    (_, tpl) := Expression.traverseExpTopDown(e1, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), inTpl);
      
        418
                    b := false;
      
                  else
      
        1317
                    (b, tpl) := (true, inTpl);
      
                  end try;
      
                end try;
      
        1735
            then (inExp, b, tpl);
      
            case (DAE.TSUB(exp=e1), tpl)
      
              algorithm
      
                try
      
          2/2✓ Branch 0 taken 59 times.
✓ Branch 1 taken 53 times.

        171
                  (_, tpl) := Expression.traverseExpTopDown(e1, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
        112
                  b := false;
      
                else
      
        ✗
                  (b, tpl) := (true, inTpl);
      
                end try;
      
        112
            then (inExp, b, tpl);
      
            // cref and $START.cref
      
            case (DAE.CREF(componentRef=cr), (pa, visitedPaths))
      
              algorithm
      
                try
      
        3136978
                  pa := adjacencyRowCref(cr, vars, pa, 0);
      
          2/2✓ Branch 0 taken 53304 times.
✓ Branch 1 taken 2405574 times.

        2458878
                  if vars.hasStartVars then
      
                    try
      
        53304
                      (varslst, _) := BackendVariable.getVar(cr, vars);
      
        53304
                      (_, p2) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        3246
                      pa := adjacencyRowExp1(varslst, p2, pa, 0);
      
                    else
      
                    end try;
      
                  end if;
      
        2458878
                  tpl := (pa, visitedPaths);
      
                else
      
        678100
                  tpl := inTpl;
      
                end try;
      
        3136978
            then (inExp, true, tpl);
      
            // der(cr), and der(cr, n) for higher derivatives during index reduction
      
            case (DAE.CALL(path=Absyn.IDENT(name="der"), expLst=DAE.CREF(componentRef=cr)::explst), (pa, visitedPaths))
      
              algorithm
      
                try
      
                  diffindx := match explst
      
                    case {} then 1;
      
                    case {DAE.ICONST(diffindx)} then diffindx;
      
                  end match;
      
        79617
                  pa := adjacencyRowCref(cr, vars, pa, diffindx);
      
        72391
                  (e, b, tpl) := (inExp, false, (pa, visitedPaths));
      
                else
      
        7226
                  (e, b, tpl) := traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
                end try;
      
        79617
            then (e, b, tpl);
      
            /* pre(v) is considered a known variable */
      
            /* previous(v) is considered a known variable */
      
            case (DAE.CALL(path=Absyn.IDENT(name=idn)), tpl) guard idn=="pre" or idn=="previous"
      
        4108
            then (inExp, false, tpl);
      
            /* delay(...) can be used to break algebraic loops given some solver options */
      
            case (DAE.CALL(path=Absyn.IDENT(name="delay"), expLst = {_, _, e1, e2}), tpl)
      
              algorithm
      
                try
      
          2/4✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 55 times.

        55
                  b := not (Flags.getConfigBool(Flags.DELAY_BREAK_LOOP) and ExpressionBasics.expEqual(e1, e2));
      
                  e := inExp;
      
                else
      
        ✗
                  (e, b, tpl) := traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
                end try;
      
        55
            then (e, b, tpl);
      
            // homotopy operator for simulation system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, _}), _) guard not isInitial
      
              algorithm
      
                try
      
        1210
                  (e, b, tpl) := traversingadjacencyRowExpSolvableFinder(e1, inTpl, vars, isInitial, ofunctionTree);
      
                else
      
        ✗
                  (e, b, tpl) := traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
                end try;
      
        1210
            then (e, b, tpl);
      
            // homotopy operator for initialization system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, e2}), _) guard isInitial
      
              algorithm
      
                try
      
        880
                  (_, b1, tpl) := traversingadjacencyRowExpSolvableFinder(e1, inTpl, vars, isInitial, ofunctionTree);
      
        880
                  (_, b2, tpl) := traversingadjacencyRowExpSolvableFinder(e2, tpl, vars, isInitial, ofunctionTree);
      
          3/4✓ Branch 0 taken 833 times.
✓ Branch 1 taken 47 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 833 times.

        927
                  (e, b) := (inExp, b1 and b2);
      
                else
      
        ✗
                  (e, b, tpl) := traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
                end try;
      
        880
            then (e, b, tpl);
      
            // only traverse position and direction for spatialDistribution, not the inputs!
      
            case (DAE.CALL(path=Absyn.IDENT(name="spatialDistribution"), expLst = {_, _, _, e1, e2, _, _}), _)
      
              algorithm
      
                try
      
        45
                  (_, _, tpl) := traversingadjacencyRowExpSolvableFinder(e2, inTpl, vars, isInitial, ofunctionTree);
      
        45
                  (e, b, tpl) := traversingadjacencyRowExpSolvableFinder(e1, tpl, vars, isInitial, ofunctionTree);
      
                else
      
        ✗
                  (e, b, tpl) := traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
                end try;
      
        45
            then (e, b, tpl);
      
            case (DAE.CALL(path=Absyn.IDENT()), _)
      
        87013
            then traversingadjacencyRowSolvableCall(inExp, inTpl, vars, isInitial, ofunctionTree);
      
        6244912
            else (inExp, true, inTpl);
      
          end match;
      
        end traversingadjacencyRowExpSolvableFinder;
      
        protected function traversingadjacencyRowSolvableCall
      
          "Uses the inlined function to analyze the occurring variables of a call,
      
          else continues into its arguments."
      
          input DAE.Exp inExp;
      
          input tuple<list<Integer>, AvlSetPath.Tree> inTpl;
      
          input BackendDAE.Variables vars;
      
          input Boolean isInitial;
      
          input Option<AvlTreePathFunction.Tree> ofunctionTree;
      
          output DAE.Exp outExp = inExp;
      
          output Boolean cont;
      
          output tuple<list<Integer>, AvlSetPath.Tree> outTpl;
      
        protected
      
          list<Integer> pa;
      
          AvlSetPath.Tree visitedPaths;
      
          AvlTreePathFunction.Tree functionTree;
      
          Absyn.Path path;
      
          DAE.Exp e1;
      
        algorithm
      
          try
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 94239 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 94239 times.

        94239
            DAE.CALL(path = path as Absyn.IDENT()) := inExp;
      
        94239
            (pa, visitedPaths) := inTpl;
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 94239 times.
✓ Branch 2 taken 1323 times.
✓ Branch 3 taken 92916 times.

        94239
            SOME(functionTree) := ofunctionTree;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 92916 times.

        92916
            false := AvlSetPath.hasKey(visitedPaths, path);
      
        92916
            (e1,_) := Inline.forceInlineCall(inExp, {}, (SOME(functionTree), {DAE.NORM_INLINE(),DAE.DEFAULT_INLINE()}));
      
          2/2✓ Branch 0 taken 92783 times.
✓ Branch 1 taken 133 times.

        92916
            false := referenceEq(inExp, e1);
      
          2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 67 times.

        199
            (_, outTpl) := Expression.traverseExpTopDown(e1, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), (pa, AvlSetPath.add(visitedPaths, path)));
      
            cont := false;
      
          else
      
        94106
            (cont, outTpl) := (true, inTpl);
      
          end try;
      
        end traversingadjacencyRowSolvableCall;
      
        protected function traversingadjacencyRowIfExpSolvableFinder
      
          "author: kabdelhak FHB 2020-01
      
          Checks if condition for special treatment, helper for only traversingadjacencyRowExpSolvableFinder.
      
              special treatment for inital() condition.
      
              Ticket: #5795
      
              ToDo: inside more complex expression? IF_EQUATION?"
      
          input output DAE.Exp e;
      
          output Boolean cont = false; // always false, just for convenience
      
          input output tuple<list<Integer>, AvlSetPath.Tree> tpl;
      
          input BackendDAE.Variables vars;
      
          input Boolean isInitial;
      
          input Option<AvlTreePathFunction.Tree> ofunctionTree;
      
        algorithm
      
          tpl := matchcontinue e
      
            local
      
              DAE.Exp expCond, expThen, expElse;
      
              Boolean conditionTrue;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse) guard(Expression.containsInitialCall(expCond))
      
              algorithm
      
                conditionTrue := match expCond
      
                  case DAE.CALL(path=Absyn.IDENT("initial")) then isInitial;
      
        ✗
                  case DAE.LUNARY(operator = DAE.NOT(), exp = DAE.CALL(path=Absyn.IDENT("initial"))) then not isInitial;
      
                  else fail(); // Lack of information, do not consider it as an initial call and traverse all branches
      
                end match;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.

        68
                if conditionTrue then
      
        ✗
                  (_, tpl) := Expression.traverseExpTopDown(expThen, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
                else
      
          1/2✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.

        136
                  (_, tpl) := Expression.traverseExpTopDown(expElse, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
                end if;
      
        68
              then tpl;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse)
      
              algorithm
      
                /* check if condition can be simplified to true or false to make it more robust against non-simplified expressions */
      
        61838
                expCond := simplifyIfCondCached(expCond);
      
                tpl := match expCond
      
                  case DAE.BCONST(true) algorithm
      
          2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 108 times.

        164
                    (_,tpl) := Expression.traverseExpTopDown(expThen, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
        136
                  then tpl;
      
                  case DAE.BCONST(false) algorithm
      
          2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 45 times.

        157
                    (_,tpl) := Expression.traverseExpTopDown(expElse, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
        101
                  then tpl;
      
                  else algorithm
      
          2/2✓ Branch 0 taken 38345 times.
✓ Branch 1 taken 23256 times.

        99946
                    (_, tpl) := Expression.traverseExpTopDown(expThen, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
        61601
                    (_, tpl) := Expression.traverseExpTopDown(expElse, function traversingadjacencyRowExpSolvableFinder(vars = vars, isInitial = isInitial, ofunctionTree = ofunctionTree), tpl);
      
        61601
                  then tpl;
      
                end match;
      
              then tpl;
      
            else
      
              algorithm
      
        ✗
                if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
                  Error.addMessage(Error.GENERIC_ELAB_EXPRESSION, {"[BackendDAEUtil.traversingadjacencyRowIfExpSolvableFinder]: " + ExpressionDump.dumpExpStr(e, 0) + ": If-Expression could not be evaluated."});
      
                end if;
      
        ✗
              then fail();
      
          end matchcontinue;
      
        end traversingadjacencyRowIfExpSolvableFinder;
      
        protected function traversingadjacencyRowIfExp
      
          "author: kabdelhak FHB 2020-01
      
          Checks if condition for special treatment, helper for all traversingadjacencyRowExp
      
          functions except traversingadjacencyRowExpSolvableFinder.
      
              special treatment for inital() condition.
      
              Ticket: #5795
      
              ToDo: inside more complex expression? IF_EQUATION?"
      
          input output DAE.Exp e;
      
          output Boolean cont = false; // always false, just for convenience
      
          input output Acc acc;
      
          input Boolean isInitial;
      
          input traverserFunction traFunc;
      
          replaceable type Acc subtypeof Any;
      
          partial function traverserFunction
      
            input output DAE.Exp exp;
      
            output Boolean cont;
      
            input output Acc acc;
      
          end traverserFunction;
      
        algorithm
      
          acc := matchcontinue e
      
            local
      
              DAE.Exp expCond, expThen, expElse;
      
              Boolean conditionTrue;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse) guard(Expression.containsInitialCall(expCond))
      
              algorithm
      
                conditionTrue := match expCond
      
                  case DAE.CALL(path=Absyn.IDENT("initial")) then isInitial;
      
        ✗
                  case DAE.LUNARY(operator = DAE.NOT(), exp = DAE.CALL(path=Absyn.IDENT("initial"))) then not isInitial;
      
                  else fail(); // Lack of information, do not consider it as an initial call and traverse all branches
      
                end match;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 120 times.

        120
                if conditionTrue then
      
        ✗
                  (_, acc) := Expression.traverseExpTopDown(expThen, traFunc, acc);
      
                else
      
        120
                  (_, acc) := Expression.traverseExpTopDown(expElse, traFunc, acc);
      
                end if;
      
        120
              then acc;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse)
      
              algorithm
      
                /* check if condition can be simplified to true or false to make it more robust against non-simplified expressions */
      
        143999
                expCond := simplifyIfCondCached(expCond);
      
                acc := match expCond
      
                  case DAE.BCONST(true) algorithm
      
        613
                    (_,acc) := Expression.traverseExpTopDown(expThen, traFunc, acc);
      
        613
                  then acc;
      
                  case DAE.BCONST(false) algorithm
      
        710
                    (_,acc) := Expression.traverseExpTopDown(expElse, traFunc, acc);
      
        710
                  then acc;
      
                  else algorithm
      
        142676
                    (_, acc) := Expression.traverseExpTopDown(expCond, traFunc, acc);
      
        142676
                    (_, acc) := Expression.traverseExpTopDown(expThen, traFunc, acc);
      
        142676
                    (_, acc) := Expression.traverseExpTopDown(expElse, traFunc, acc);
      
        142676
                  then acc;
      
                end match;
      
              then acc;
      
            else
      
              algorithm
      
        ✗
                if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
                  Error.addMessage(Error.GENERIC_ELAB_EXPRESSION, {"[BackendDAEUtil.traversingadjacencyRowIfExp]: " + ExpressionDump.dumpExpStr(e, 0) + ": If-Expression could not be evaluated."});
      
                end if;
      
        ✗
              then fail();
      
          end matchcontinue;
      
        end traversingadjacencyRowIfExp;
      
        protected function simplifyIfCondCached
      
          "The same if-conditions are simplified in every adjacency row of every
      
           matrix build (thousands per translation); cleared in getSolvedSystem."
      
          input DAE.Exp cond;
      
          output DAE.Exp simplified;
      
        protected
      
          Option<HashTableExpToExp.HashTable> opt;
      
          HashTableExpToExp.HashTable ht;
      
        algorithm
      
        211416
          opt := getGlobalRoot(Global.adjacencyIfCondCache);
      
          ht := match opt
      
            case SOME(ht) then ht;
      
        374
            else HashTableExpToExp.emptyHashTableSized(1013);
      
          end match;
      
          try
      
        211416
            simplified := BaseHashTable.get(cond, ht);
      
          else
      
        6480
            simplified := ExpressionSimplify.simplify(cond);
      
        6480
            ht := BaseHashTable.add((cond, simplified), ht);
      
        6480
            setGlobalRoot(Global.adjacencyIfCondCache, SOME(ht));
      
          end try;
      
        end simplifyIfCondCached;
      
        protected function traversingAdjacencyRowIfExpEnhanced
      
          "author: kabdelhak FHB 2020-01
      
          Checks if condition for special treatment, helper for traversingAdjacencyRowExpSolvableEnhancedFinder.
      
              special treatment for initial() condition.
      
              Ticket: #5795
      
              ToDo: inside more complex expression?"
      
          input output DAE.Exp e;
      
          output Boolean cont = false; // always false, just for convenience
      
          input output tuple<BackendDAE.Variables, Boolean, Boolean, Integer, array<Integer>, list<Integer>> tpl;
      
          input traverserFunction traFunc;
      
          partial function traverserFunction
      
            input output DAE.Exp exp;
      
            output Boolean cont;
      
            input output tuple<BackendDAE.Variables, Boolean, Boolean, Integer, array<Integer>, list<Integer>> tpl;
      
          end traverserFunction;
      
        algorithm
      
          tpl := matchcontinue e
      
            local
      
              DAE.Exp expCond, expThen, expElse;
      
              Boolean isInitial, conditionTrue, bs;
      
              BackendDAE.Variables vars;
      
              Integer it, mark;
      
              array<Integer> at, rowmark;
      
              list<Integer> pa;
      
              BinaryTree.BinTree bt;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse) guard(Expression.containsInitialCall(expCond))
      
              algorithm
      
        ✗
                (_, _, isInitial, _, _, _) := tpl;
      
                conditionTrue := match expCond
      
                  case DAE.CALL(path=Absyn.IDENT("initial")) then isInitial;
      
        ✗
                  case DAE.LUNARY(operator = DAE.NOT(), exp = DAE.CALL(path=Absyn.IDENT("initial"))) then not isInitial;
      
                  else fail(); // Lack of information, do not consider it as an initial call and traverse all branches
      
                end match;
      
        ✗
                if conditionTrue then
      
        ✗
                  (_, tpl) := Expression.traverseExpTopDown(expThen, traFunc, tpl);
      
                else
      
        ✗
                  (_, tpl) := Expression.traverseExpTopDown(expElse, traFunc, tpl);
      
                end if;
      
        ✗
              then tpl;
      
            case DAE.IFEXP(expCond = expCond, expThen = expThen, expElse = expElse)
      
              algorithm
      
                /* check if condition can be simplified to true or false to make it more robust against non-simplified expressions */
      
        5579
                expCond := simplifyIfCondCached(expCond);
      
                tpl := match expCond
      
                  case DAE.BCONST(true) algorithm
      
        ✗
                    (_, tpl) := Expression.traverseExpTopDown(expThen, traFunc, tpl);
      
        ✗
                  then tpl;
      
                  case DAE.BCONST(false) algorithm
      
        ✗
                    (_, tpl) := Expression.traverseExpTopDown(expElse, traFunc, tpl);
      
        ✗
                  then tpl;
      
                  else algorithm
      
          2/2✓ Branch 0 taken 1751 times.
✓ Branch 1 taken 3828 times.

        5579
                    (vars, bs, isInitial, it, at, pa) := tpl;
      
                    mark := it;
      
                    rowmark := at;
      
          3/4✓ Branch 0 taken 1751 times.
✓ Branch 1 taken 3828 times.
✓ Branch 2 taken 5579 times.
✗ Branch 3 not taken.

        12909
                    (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(expThen, traFunc, (vars, bs, isInitial, it, at, pa));
      
        5579
                    (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(expElse, traFunc, (vars, bs, isInitial, it, at, pa));
      
        5579
                    (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(expCond, traFunc, (vars, true, isInitial, it, at, pa));
      
                    // mark all vars which are not in all branches unsolvable
      
        5579
                    (_, bt) := Expression.traverseExpTopDown(e, getIfExpBranchVarOccurency, BinaryTree.emptyBinTree);
      
        5579
                    Expression.traverseExpTopDown(expThen, markBranchVars, (mark, rowmark, vars, bt));
      
        5579
                    Expression.traverseExpTopDown(expElse, markBranchVars, (mark, rowmark, vars, bt));
      
        5579
                  then (vars, bs, isInitial, it, at, pa);
      
                end match;
      
              then tpl;
      
            else
      
              algorithm
      
        ✗
                if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
                  Error.addMessage(Error.GENERIC_ELAB_EXPRESSION, {"[BackendDAEUtil.traversingAdjacencyRowIfExpEnhanced]: " + ExpressionDump.dumpExpStr(e, 0) + ": If-Expression could not be evaluated."});
      
                end if;
      
        ✗
              then fail();
      
          end matchcontinue;
      
        end traversingAdjacencyRowIfExpEnhanced;
      
        public function traversingAdjacencyRowExpFinderBaseClock "author: lochel
      
          This is used for base-clock partitioning."
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables, list<Integer>, Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables, list<Integer>, Boolean> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              list<Integer> p, p2;
      
              list<Integer> pa;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              DAE.Exp e;
      
              Boolean isInitial;
      
              tuple<BackendDAE.Variables,list<Integer>, Boolean> tpl;
      
            case (DAE.CREF(componentRef=cr), (vars, pa, isInitial))
      
              algorithm
      
        552164
                (_, p) := BackendVariable.getVar(cr, vars);
      
        497507
                pa := listAppend(p, pa);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 497507 times.

        497507
                if vars.hasStartVars then
      
                  try
      
        ✗
                    (_, p2) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        ✗
                    pa := listAppend(p2, pa);
      
                  else
      
                  end try;
      
                end if;
      
          1/2✓ Branch 0 taken 497507 times.
✗ Branch 1 not taken.

        995014
              then (inExp, true, (vars, pa, isInitial));
      
            case (DAE.CALL(path=Absyn.IDENT(name="sample"), expLst={_, e}), _)
      
              algorithm
      
        89
                (_, outTpl) := Expression.traverseExpTopDown(e, traversingAdjacencyRowExpFinderBaseClock, inTpl);
      
        89
              then (inExp, false, outTpl);
      
            case (DAE.CLKCONST(DAE.SOLVER_CLOCK(e)), _)
      
              algorithm
      
        2
                (_, outTpl) := Expression.traverseExpTopDown(e, traversingAdjacencyRowExpFinderBaseClock, inTpl);
      
        2
              then (inExp, true, outTpl);
      
            case (DAE.CLKCONST(DAE.EVENT_CLOCK()), _)
      
        11
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="hold")), _)
      
        15
              then (inExp, false, inTpl);
      
            case (DAE.IFEXP(), tpl) algorithm
      
        6751
            then traversingadjacencyRowIfExp(inExp, tpl, Util.tuple33(tpl), traversingAdjacencyRowExpFinderBaseClock);
      
        1040994
            else (inExp, true, inTpl);
      
          end matchcontinue;
      
        end traversingAdjacencyRowExpFinderBaseClock;
      
        public function traversingAdjacencyRowExpFinderSubClock "author: lochel
      
          This is used for sub-clock partitioning.
      
          TODO: avoid code duplicates, cf. function traversingAdjacencyRowExpFinderBaseClock"
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables, list<Integer>, Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables, list<Integer>, Boolean> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              list<Integer> p, p2;
      
              list<Integer> pa, res;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              Boolean isInitial;
      
              tuple<BackendDAE.Variables,list<Integer>, Boolean> tpl;
      
            case (DAE.CREF(componentRef=cr), (vars, pa, isInitial))
      
              algorithm
      
        3592
                (_, p) := BackendVariable.getVar(cr, vars);
      
        3125
                res := listAppend(p, pa);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3125 times.

        3125
                if vars.hasStartVars then
      
                  try
      
        ✗
                    (_, p2) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        ✗
                    res := listAppend(p2, res);
      
                  else
      
                  end try;
      
                end if;
      
          1/2✓ Branch 0 taken 3125 times.
✗ Branch 1 not taken.

        6250
              then (inExp, true, (vars, res, isInitial));
      
            case (DAE.CALL(path=Absyn.IDENT(name="subSample")), _)
      
        6
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="superSample")), _)
      
        13
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="shiftSample")), _)
      
        5
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="backSample")), _)
      
        3
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path=Absyn.IDENT(name="noClock")), _)
      
        ✗
              then (inExp, false, inTpl);
      
            case (DAE.IFEXP(), tpl) algorithm
      
        660
            then traversingadjacencyRowIfExp(inExp, tpl, Util.tuple33(tpl), traversingAdjacencyRowExpFinderSubClock);
      
        4129
            else (inExp, true, inTpl);
      
          end matchcontinue;
      
        end traversingAdjacencyRowExpFinderSubClock;
      
        public function traversingadjacencyRowExpFinder "
      
          author: Frenkel TUD 2010-11
      
          Helper for statesAndVarsExp. Bind vars and isInitial by partial application;
      
          only the row is threaded through the traversal."
      
          input DAE.Exp inExp;
      
          input list<Integer> inPa;
      
          input BackendDAE.Variables vars;
      
          input Boolean isInitial;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output list<Integer> outPa;
      
        algorithm
      
          (outExp,cont,outPa) := match inExp
      
            local
      
              list<Integer> p2, pa;
      
              DAE.ComponentRef cr;
      
              DAE.Exp e,e1,e2;
      
              list<BackendDAE.Var> varslst;
      
              Boolean b, b1, b2;
      
              Integer i;
      
            // cref and $START.cref
      
            case DAE.CREF(componentRef=cr)
      
              algorithm
      
                try
      
        7095555
                  pa := adjacencyRowCref(cr, vars, inPa, 0);
      
          2/2✓ Branch 0 taken 164999 times.
✓ Branch 1 taken 5406310 times.

        5571309
                  if vars.hasStartVars then
      
                    try
      
        164999
                      (varslst, _) := BackendVariable.getVar(cr, vars);
      
        164999
                      (_, p2) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        4576
                      pa := adjacencyRowExp1(varslst, p2, pa, 0);
      
                    else
      
                    end try;
      
                  end if;
      
                else
      
        1524246
                  pa := inPa;
      
                end try;
      
        7095555
              then (inExp, true, pa);
      
            case DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)})
      
              algorithm
      
                try
      
        119901
                  pa := traversingadjacencyRowDer(cr, vars, inPa, isInitial);
      
        104150
                  b := false;
      
                else
      
                  try
      
        15751
                    pa := traversingadjacencyRowDer(ComponentReference.crefPrefixDer(cr), vars, inPa, isInitial);
      
        ✗
                    b := false;
      
                  else
      
        15751
                    (b, pa) := (true, inPa);
      
                  end try;
      
                end try;
      
        119901
              then (inExp, b, pa);
      
            /* pre(v) is considered a known variable */
      
            case DAE.CALL(path = Absyn.IDENT(name = "pre"),expLst = {DAE.CREF()}) then (inExp,false,inPa);
      
            /* previous(v) is considered a known variable */
      
            case DAE.CALL(path = Absyn.IDENT(name = "previous"),expLst = {DAE.CREF()}) then (inExp,false,inPa);
      
            /* delay(e) can be used to break algebraic loops given some solver options */
      
            case DAE.CALL(path = Absyn.IDENT(name = "delay"),expLst = {_,_,e1,e2})
      
              algorithm
      
                try
      
          2/4✓ Branch 1 taken 270 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 270 times.

        270
                  b := not (Flags.getConfigBool(Flags.DELAY_BREAK_LOOP) and ExpressionBasics.expEqual(e1,e2));
      
                else
      
        ✗
                  b := true;
      
                end try;
      
        270
              then (inExp,b,inPa);
      
            // homotopy operator for simulation system
      
            case DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, _}) guard not isInitial
      
              algorithm
      
                try
      
        2191
                  (e, b, pa) := traversingadjacencyRowExpFinder(e1, inPa, vars, isInitial);
      
                else
      
        ✗
                  (e, b, pa) := (inExp, true, inPa);
      
                end try;
      
        2191
              then (e, b, pa);
      
            // homotopy operator for initialization system
      
            case DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, e2}) guard isInitial
      
              algorithm
      
                try
      
        1678
                  (_, b1, pa) := traversingadjacencyRowExpFinder(e1, inPa, vars, isInitial);
      
        1678
                  (_, b2, pa) := traversingadjacencyRowExpFinder(e2, pa, vars, isInitial);
      
          3/4✓ Branch 0 taken 1570 times.
✓ Branch 1 taken 108 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1570 times.

        1786
                  b := b1 and b2;
      
                else
      
        ✗
                  (b, pa) := (true, inPa);
      
                end try;
      
        1678
            then (inExp, b, pa);
      
            // only traverse position and direction for spatialDistribution, not the inputs!
      
            case DAE.CALL(path=Absyn.IDENT(name="spatialDistribution"), expLst = {_, _, _, e1, e2, _, _})
      
              algorithm
      
                try
      
        116
                  (_, _, pa) := traversingadjacencyRowExpFinder(e2, inPa, vars, isInitial);
      
        116
                  (e, b, pa) := traversingadjacencyRowExpFinder(e1, pa, vars, isInitial);
      
                else
      
        ✗
                  (e, b, pa) := (inExp, true, inPa);
      
                end try;
      
        116
            then (e, b, pa);
      
            // a failing scalar lookup falls back to the element of the array expression
      
            case DAE.ASUB(exp = e1, sub={DAE.INDEX(DAE.ICONST(i))})
      
              algorithm
      
                try
      
                  try
      
          2/2✓ Branch 0 taken 10725 times.
✓ Branch 1 taken 22 times.

        10747
                    DAE.CREF(componentRef=cr) := e1;
      
        22
                    cr := ComponentReference.subscriptCrefWithInt(cr, i);
      
        22
                    pa := adjacencyRowCref(cr, vars, inPa, 0);
      
                  else
      
        10732
                    e1 := Expression.nthArrayExp(e1, i);
      
          2/2✓ Branch 0 taken 10595 times.
✓ Branch 1 taken 137 times.

        21327
                    (_, pa) := Expression.traverseExpTopDown(e1, function traversingadjacencyRowExpFinder(vars = vars, isInitial = isInitial), inPa);
      
                  end try;
      
        10747
                  b := false;
      
                else
      
        ✗
                  (b, pa) := (true, inPa);
      
                end try;
      
        10747
              then (inExp, b, pa);
      
            case DAE.IFEXP()
      
              algorithm
      
                try
      
          2/2✓ Branch 0 taken 85092 times.
✓ Branch 1 taken 38746 times.

        208930
                  (e, b, pa) := traversingadjacencyRowIfExp(inExp, inPa, isInitial, function traversingadjacencyRowExpFinder(vars = vars, isInitial = isInitial));
      
                else
      
        ✗
                  (e, b, pa) := (inExp, true, inPa);
      
                end try;
      
        123838
              then (e, b, pa);
      
            else (inExp,true,inPa);
      
          end match;
      
        end traversingadjacencyRowExpFinder;
      
        protected function traversingadjacencyRowDer
      
          "The der(cr) case of traversingadjacencyRowExpFinder, including the
      
          indices of cr."
      
          input DAE.ComponentRef cr;
      
          input BackendDAE.Variables vars;
      
          input list<Integer> inPa;
      
          input Boolean isInitial;
      
          output list<Integer> pa;
      
        algorithm
      
        135652
          pa := adjacencyRowCref(cr, vars, inPa, 1);
      
          1/2✓ Branch 0 taken 104150 times.
✗ Branch 1 not taken.

        208300
          (_, pa) := Expression.traverseExpTopDownCrefHelper(cr, function traversingadjacencyRowExpFinder(vars = vars, isInitial = isInitial), pa);
      
        end traversingadjacencyRowDer;
      
        protected function adjacencyRowExp1
      
          "Adds an adjacency matrix entry for all variables in the inVarLst."
      
          input list<BackendDAE.Var> inVarLst;
      
          input list<Integer> inIntegerLst;
      
          input list<Integer> inVarIndxLst;
      
          input Integer diffindex;
      
          output list<Integer> outVarIndxLst;
      
        algorithm
      
          outVarIndxLst := match (inVarLst,inIntegerLst)
      
            local
      
               BackendDAE.Var v;
      
               list<BackendDAE.Var> rest;
      
               list<Integer> irest;
      
               Integer i;
      
            case ({},{}) then inVarIndxLst;
      
            case (v::rest,i::irest)
      
        476223
              then adjacencyRowExp1(rest,irest,adjacencyRowVar(v,i,inVarIndxLst,diffindex),diffindex);
      
          end match;
      
        end adjacencyRowExp1;
      
        protected function adjacencyRowVar
      
          "Adds the adjacency matrix entry of variable i: a state x enters as -i
      
           unless diffindex says der(x) is meant (used by index reduction)."
      
          input BackendDAE.Var var;
      
          input Integer i;
      
          input list<Integer> inRow;
      
          input Integer diffindex;
      
          output list<Integer> row;
      
        algorithm
      
          row := match var
      
            local
      
              Integer diffidx;
      
            case BackendDAE.VAR(varKind = BackendDAE.STATE(derName=SOME(_)))
      
          2/2✓ Branch 0 taken 176771 times.
✓ Branch 1 taken 34399 times.

        211170
              then (if intGe(diffindex,1) then i else -i) :: inRow;
      
            case BackendDAE.VAR(varKind = BackendDAE.STATE(index=diffidx))
      
          2/2✓ Branch 0 taken 603773 times.
✓ Branch 1 taken 139110 times.

        742883
              then (if intGe(diffindex,diffidx) then i else -i) :: inRow;
      
            else i :: inRow;
      
          end match;
      
        end adjacencyRowVar;
      
        protected function adjacencyRowCref
      
          "adjacencyRowExp1 for the variables cr names, as BackendVariable.getVar
      
           finds them, without building lists for a single variable. Fails if cr
      
           names none."
      
          input DAE.ComponentRef cr;
      
          input BackendDAE.Variables vars;
      
          input list<Integer> inRow;
      
          input Integer diffindex;
      
          output list<Integer> row;
      
        protected
      
          Integer hash = ComponentReferenceBasics.hashComponentRef(cr);
      
          BackendDAE.Var v;
      
          Integer i;
      
          list<BackendDAE.Var> vl;
      
          list<Integer> il;
      
        algorithm
      
          try
      
        10447824
            (v, i) := BackendVariable.getVarHashed(cr, hash, vars);
      
        8154854
            row := adjacencyRowVar(v, i, inRow, diffindex);
      
          else
      
        2292970
            (vl, il) := BackendVariable.getVarExpanded(cr, hash, vars);
      
        51889
            row := adjacencyRowExp1(vl, il, inRow, diffindex);
      
          end try;
      
        end adjacencyRowCref;
      
        protected function adjacencyRowExp1DiscreteOrArray
      
          "Adds an adjacency matrix entry for all variables in the inVarLst, if they are discrete."
      
          input list<BackendDAE.Var> inVarLst;
      
          input list<Integer> inIntegerLst;
      
          input list<Integer> inVarIndxLst;
      
          output list<Integer> outVarIndxLst;
      
        algorithm
      
          outVarIndxLst := match (inVarLst,inIntegerLst)
      
            local
      
               list<BackendDAE.Var> rest;
      
               list<Integer> irest;
      
               list<Integer> vars;
      
               Integer i;
      
            case ({}, {}) then inVarIndxLst;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE())::rest, i::irest)
      
              algorithm
      
                vars := i :: inVarIndxLst;
      
        20356
              then adjacencyRowExp1DiscreteOrArray(rest,irest,vars);
      
            case (_::rest, _::irest)
      
        3895
              then adjacencyRowExp1DiscreteOrArray(rest,irest,inVarIndxLst);
      
          end match;
      
        end adjacencyRowExp1DiscreteOrArray;
      
        public function traversingadjacencyRowExpFinderwithInput "Helper for statesAndVarsExp"
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,list<Integer>, Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables,list<Integer>, Boolean> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := matchcontinue (inExp,inTpl)
      
          local
      
              list<Integer> p;
      
              list<Integer> pa, res;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              DAE.Exp e1, e2;
      
              list<BackendDAE.Var> varslst;
      
              tuple<BackendDAE.Variables,list<Integer>, Boolean> tpl;
      
              Boolean b1, b2, isInitial;
      
            // inner variable
      
            case (DAE.CREF(componentRef = cr),(vars,pa,isInitial))
      
              algorithm
      
        697032
                cr := ComponentReferenceBasics.makeCrefQual(BackendDAE.partialDerivativeNamePrefix, DAE.T_REAL_DEFAULT, {}, cr);
      
        697032
                (varslst,p) := BackendVariable.getVar(cr, vars);
      
        105667
                res := adjacencyRowExp1withInput(varslst,p,pa,0);
      
          2/2✓ Branch 0 taken 100872 times.
✓ Branch 1 taken 4795 times.

        206539
              then (inExp,false,(vars,res,isInitial));
      
            // iteration var, with its start value if it has one
      
            case (DAE.CREF(componentRef=cr), (vars, pa, isInitial))
      
              algorithm
      
        591365
                (varslst, p) := BackendVariable.getVar(cr, vars);
      
        364113
                res := adjacencyRowExp1withInput(varslst, p, pa, 0);
      
          2/2✓ Branch 0 taken 3065 times.
✓ Branch 1 taken 361048 times.

        364113
                if vars.hasStartVars then
      
                  try
      
        3065
                    (varslst, p) := BackendVariable.getVar(ComponentReference.crefPrefixStart(cr), vars);
      
        33
                    res := adjacencyRowExp1withInput(varslst, p, res, 0);
      
                  else
      
                  end try;
      
                end if;
      
          2/2✓ Branch 0 taken 356447 times.
✓ Branch 1 taken 7666 times.

        720560
              then (inExp, true, (vars, res, isInitial));
      
            // state derivative (in backend)
      
            case (DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,pa,isInitial))
      
              algorithm
      
        10580
                (varslst,p) := BackendVariable.getVar(cr, vars);
      
        7300
                res := adjacencyRowExp1withInput(varslst,p,pa,1);
      
          1/2✓ Branch 0 taken 7300 times.
✗ Branch 1 not taken.

        14600
              then (inExp,false,(vars,res,isInitial));
      
            // state derivative (in simcode)
      
            case (DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),(vars,pa,isInitial))
      
              algorithm
      
        3280
                cr := ComponentReference.crefPrefixDer(cr);
      
        3280
                (varslst,p) := BackendVariable.getVar(cr, vars);
      
        ✗
                res := adjacencyRowExp1withInput(varslst,p,pa,1);
      
        ✗
              then (inExp,false,(vars,res,isInitial));
      
            // CLOCKED state
      
            case (DAE.CALL(path = Absyn.IDENT(name = "previous"),expLst = {DAE.CREF(componentRef = cr)}),(vars,pa,isInitial))
      
              algorithm
      
        6
                cr := ComponentReferenceBasics.makeCrefQual(DAE.previousNamePrefix, DAE.T_REAL_DEFAULT, {}, cr);
      
        6
                (varslst,p) := BackendVariable.getVar(cr, vars);
      
        6
                res := adjacencyRowExp1withInput(varslst,p,pa,1);
      
          1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.

        12
              then (inExp,false,(vars,res,isInitial));
      
            // homotopy operator for simulation system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, _}), (_, _, false))
      
        286
            then traversingadjacencyRowExpFinderwithInput(e1, inTpl);
      
            // homotopy operator for initialization system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, e2}), (_, _, true))
      
              algorithm
      
        2
                (_, b1, tpl) := traversingadjacencyRowExpFinderwithInput(e1, inTpl);
      
        2
                (_, b2, tpl) := traversingadjacencyRowExpFinderwithInput(e2, tpl);
      
          2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

        2
            then (inExp, b1 and b2, tpl);
      
            // only traverse position and direction for spatialDistribution, not the inputs!
      
            case (DAE.CALL(path=Absyn.IDENT(name="spatialDistribution"), expLst = {_, _, _, e1, e2, _, _}), _)
      
              algorithm
      
        8
                (_, _, tpl) := traversingadjacencyRowExpFinderwithInput(e2, inTpl);
      
        8
            then traversingadjacencyRowExpFinderwithInput(e1, tpl);
      
            /* pre(v) is considered a known variable */
      
        1535
            case (DAE.CALL(path = Absyn.IDENT(name = "pre"),expLst = {DAE.CREF()}),_) then (inExp,false,inTpl);
      
            case (DAE.IFEXP(), tpl) algorithm
      
        12870
            then traversingadjacencyRowIfExp(inExp, tpl, Util.tuple33(tpl), traversingadjacencyRowExpFinderwithInput);
      
        1472247
            else (inExp,true,inTpl);
      
          end matchcontinue;
      
        end traversingadjacencyRowExpFinderwithInput;
      
        protected function adjacencyRowExp1withInput
      
          input list<BackendDAE.Var> inVarLst;
      
          input list<Integer> inIntegerLst;
      
          input list<Integer> vars;
      
          input Integer diffindex;
      
          output list<Integer> outIntegerLst;
      
        algorithm
      
          outIntegerLst := match (inVarLst, inIntegerLst)
      
            local
      
               list<BackendDAE.Var> rest;
      
               list<Integer> irest;
      
               Integer i;
      
            case ({}, {}) then vars;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DAE_AUX_VAR())::rest, i::irest)
      
        155
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.DAE_RESIDUAL_VAR())::rest, i::irest)
      
        3800
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.JAC_TMP_VAR())::rest, i::irest)
      
        105679
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE())::rest, i::irest)
      
              guard diffindex <> 0
      
        7298
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE_DER())::rest, i::irest)
      
        771
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.CLOCKED_STATE())::rest, i::irest)
      
        22
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.VARIABLE())::rest, i::irest)
      
        254921
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.ALG_STATE())::rest, i::irest)
      
        816
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE())::rest, i::irest)
      
        7582
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_DER())::rest, i::irest)
      
        30357
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_STATE())::rest, i::irest)
      
        60420
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.OPT_CONSTR())::rest, i::irest)
      
        377
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (BackendDAE.VAR(varKind = BackendDAE.OPT_FCONSTR())::rest, i::irest)
      
        135
              then adjacencyRowExp1(rest,irest,i::vars,diffindex);
      
            case (_ :: _, _::_)
      
              then vars;
      
          end match;
      
        end adjacencyRowExp1withInput;
      
        public function updateAdjacencyMatrix
      
        "author: PA
      
          Takes a daelow and the adjacency matrix and its transposed
      
          represenation and a list of  equation indexes that needs to be updated.
      
          First the BackendDAE.AdjacencyMatrix is updated, i.e. the mapping from equations
      
          to variables. Then, by collecting all variables in the list of equations
      
          to update, a list of changed variables are retrieved. This is used to
      
          update the BackendDAE.AdjacencyMatrixT (transpose) mapping from variables to
      
          equations. The function returns an updated adjacency matrix.
      
          inputs:  (BackendDAE,
      
                    AdjacencyMatrix,
      
                    AdjacencyMatrixT,
      
                    int list /* list of equations to update */)
      
          outputs: (AdjacencyMatrix, AdjacencyMatrixT)"
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inIntegerLst;
      
          input Boolean isInitial;
      
          output BackendDAE.EqSystem osyst;
      
        algorithm
      
          osyst := matchcontinue syst
      
            local
      
              BackendDAE.AdjacencyMatrix m;
      
              BackendDAE.AdjacencyMatrixT mt;
      
              BackendDAE.Variables vars;
      
              BackendDAE.EquationArray daeeqns;
      
              BackendDAE.AdjacencyMatrixMapping mapping;
      
            case BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=daeeqns, m=SOME(m), mT=SOME(mt), mapping=SOME(mapping))
      
              algorithm
      
                /* kabdelhak: throw warning for unequal index types - inIndexType - indexType? also scalar function check!*/
      
        20148
                (m,mt) := updateAdjacencyMatrix1(vars, daeeqns, inIndxType, functionTree, m, mt, inIntegerLst, isInitial);
      
        40296
              then BackendDAEUtil.setEqSystMatrices(syst, SOME(m), SOME(mt), SOME(mapping));
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"BackendDAEUtil.updateAdjacencyMatrix failed"});
      
        ✗
              then fail();
      
          end matchcontinue;
      
        end updateAdjacencyMatrix;
      
        protected function updateAdjacencyMatrix1
      
          "Replaces the rows of the given equations, then rebuilds the transposed row of
      
           every variable an equation gained or lost once, with the result the one-by-one
      
           removals and prepends would give."
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.EquationArray daeeqns;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input output BackendDAE.AdjacencyMatrix m;
      
          input output BackendDAE.AdjacencyMatrixT mt;
      
          input list<Integer> inIntegerLst;
      
          input Boolean isInitial;
      
        protected
      
          Integer abse, size = 0;
      
          list<Integer> row, oldvars;
      
          AvlSetInt.Tree invars, outvars;
      
          list<tuple<Integer, Integer>> removed = {}, added = {} "(variable, signed equation)";
      
          array<list<Integer>> removedAt, addedAt;
      
          array<Integer> markPos, markNeg;
      
        algorithm
      
          2/2✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 20148 times.

        22452
          for e in inIntegerLst loop
      
        2304
            abse := intAbs(e);
      
        2304
            (row, _) := adjacencyRow(BackendEquation.get(daeeqns, abse), vars, inIndxType, functionTree, {}, isInitial);
      
        2304
            row := uniqueRow(row);
      
        2304
            oldvars := getOldVars(m, abse);
      
        2304
            m := Array.replaceAtWithFill(abse, row, {}, m);
      
        2304
            (_, outvars, invars) := AvlSetInt.intersection(AvlSetInt.addList(AvlSetInt.EMPTY(), oldvars), AvlSetInt.addList(AvlSetInt.EMPTY(), row));
      
          2/2✓ Branch 1 taken 2946 times.
✓ Branch 2 taken 2304 times.

        5250
            for k in AvlSetInt.listKeys(outvars) loop
      
          2/2✓ Branch 0 taken 243 times.
✓ Branch 1 taken 2703 times.

        2946
              removed := (intAbs(k), if k > 0 then abse else -abse) :: removed;
      
            end for;
      
          2/2✓ Branch 1 taken 2228 times.
✓ Branch 2 taken 2304 times.

        4532
            for k in AvlSetInt.listKeys(invars) loop
      
          2/2✓ Branch 0 taken 371 times.
✓ Branch 1 taken 1857 times.

        2228
              added := (intAbs(k), if k > 0 then abse else -abse) :: added;
      
              size := max(size, intAbs(k));
      
            end for;
      
          end for;
      
          4/4✓ Branch 0 taken 19896 times.
✓ Branch 1 taken 252 times.
✓ Branch 2 taken 19891 times.
✓ Branch 3 taken 5 times.

        20148
          if listEmpty(removed) and listEmpty(added) then
      
        19891
            return;
      
          end if;
      
        257
          mt := Array.expandToSize(size, mt, {});
      
        257
          removedAt := arrayCreate(arrayLength(mt), {});
      
        257
          addedAt := arrayCreate(arrayLength(mt), {});
      
          2/2✓ Branch 0 taken 2946 times.
✓ Branch 1 taken 257 times.

        3203
          for r in removed loop
      
        5892
            arrayUpdate(removedAt, Util.tuple21(r), Util.tuple22(r) :: removedAt[Util.tuple21(r)]);
      
          end for;
      
          // consed from the last addition back, so each list is in processing order
      
          2/2✓ Branch 0 taken 2228 times.
✓ Branch 1 taken 257 times.

        2485
          for a in added loop
      
        4456
            arrayUpdate(addedAt, Util.tuple21(a), Util.tuple22(a) :: addedAt[Util.tuple21(a)]);
      
          end for;
      
        257
          markPos := arrayCreate(arrayLength(m), 0);
      
        257
          markNeg := arrayCreate(arrayLength(m), 0);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 257 times.

        79850
          for k in 1:arrayLength(mt) loop
      
          4/4✓ Branch 1 taken 77530 times.
✓ Branch 2 taken 2063 times.
✓ Branch 4 taken 1776 times.
✓ Branch 5 taken 75754 times.

        79593
            if not (listEmpty(removedAt[k]) and listEmpty(addedAt[k])) then
      
        3839
              row := mt[k];
      
          2/2✓ Branch 0 taken 2063 times.
✓ Branch 1 taken 1776 times.

        3839
              if not listEmpty(removedAt[k]) then
      
          2/2✓ Branch 0 taken 2946 times.
✓ Branch 1 taken 2063 times.

        5009
                for v in removedAt[k] loop
      
        2946
                  setSignedMark(v, k, markPos, markNeg);
      
                end for;
      
          6/6✓ Branch 1 taken 2946 times.
✓ Branch 2 taken 8054 times.
✓ Branch 3 taken 11000 times.
✓ Branch 4 taken 2063 times.
✓ Branch 5 taken 8054 times.
✓ Branch 6 taken 2063 times.

        13063
                row := list(v for v guard not hasSignedMark(v, k, markPos, markNeg) in row);
      
              end if;
      
          2/2✓ Branch 1 taken 1779 times.
✓ Branch 2 taken 2060 times.

        3839
              if not listEmpty(addedAt[k]) then
      
          2/2✓ Branch 0 taken 3747 times.
✓ Branch 1 taken 1779 times.

        5526
                for v in row loop
      
        3747
                  setSignedMark(v, -k, markPos, markNeg);
      
                end for;
      
          2/2✓ Branch 1 taken 2228 times.
✓ Branch 2 taken 1779 times.

        4007
                for v in addedAt[k] loop
      
          1/2✓ Branch 1 taken 2228 times.
✗ Branch 2 not taken.

        2228
                  if not hasSignedMark(v, -k, markPos, markNeg) then
      
                    row := v :: row;
      
                  end if;
      
                end for;
      
              end if;
      
        3839
              arrayUpdate(mt, k, row);
      
            end if;
      
          end for;
      
        end updateAdjacencyMatrix1;
      
        protected function setSignedMark
      
          input Integer v;
      
          input Integer stamp;
      
          input array<Integer> markPos;
      
          input array<Integer> markNeg;
      
        algorithm
      
          3/4✓ Branch 0 taken 6079 times.
✓ Branch 1 taken 614 times.
✓ Branch 2 taken 6079 times.
✗ Branch 3 not taken.

        12772
          if v > 0 and v <= arrayLength(markPos) then
      
        6079
            arrayUpdate(markPos, v, stamp);
      
          elseif v < 0 and -v <= arrayLength(markNeg) then
      
        614
            arrayUpdate(markNeg, -v, stamp);
      
          end if;
      
        end setSignedMark;
      
        protected function hasSignedMark
      
          input Integer v;
      
          input Integer stamp;
      
          input array<Integer> markPos;
      
          input array<Integer> markNeg;
      
          output Boolean marked = false;
      
        algorithm
      
          2/2✓ Branch 0 taken 11356 times.
✓ Branch 1 taken 1872 times.

        13228
          if v > 0 then
      
          1/2✓ Branch 0 taken 11356 times.
✗ Branch 1 not taken.

        11356
            if v <= arrayLength(markPos) then
      
        11356
              marked := markPos[v] == stamp;
      
            end if;
      
          elseif v < 0 then
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1872 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1872 times.

        3744
            if -v <= arrayLength(markNeg) then
      
        1872
              marked := markNeg[-v] == stamp;
      
            end if;
      
          end if;
      
        end hasSignedMark;
      
        public function updateAdjacencyMatrixScalar
      
        "author: PA
      
          Takes a daelow and the adjacency matrix and its transposed
      
          represenation and a list of  equation indexes that needs to be updated.
      
          First the BackendDAE.AdjacencyMatrix is updated, i.e. the mapping from equations
      
          to variables. Then, by collecting all variables in the list of equations
      
          to update, a list of changed variables are retrieved. This is used to
      
          update the BackendDAE.AdjacencyMatrixT (transpose) mapping from variables to
      
          equations. The function returns an updated adjacency matrix.
      
          inputs:  (BackendDAE,
      
                    AdjacencyMatrix,
      
                    AdjacencyMatrixT,
      
                    int list /* list of equations to update */)
      
          outputs: (AdjacencyMatrix, AdjacencyMatrixT)"
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input list<Integer> inIntegerLst "numbers of equations in BackendDAE.EquationArray";
      
          input array<list<Integer>> iMapEqnIncRow;
      
          input array<Integer> iMapIncRowEqn;
      
          input Boolean isInitial;
      
          output BackendDAE.EqSystem osyst;
      
          output array<list<Integer>> oMapEqnIncRow;
      
          output array<Integer> oMapIncRowEqn;
      
        algorithm
      
          (osyst, oMapEqnIncRow, oMapIncRowEqn) := matchcontinue syst
      
            local
      
              BackendDAE.AdjacencyMatrix m;
      
              BackendDAE.AdjacencyMatrixT mt;
      
              Integer oldsize, newsize, oldsize1, newsize1, deltasize;
      
              list<Integer> eqns;
      
              BackendDAE.Variables vars;
      
              BackendDAE.EquationArray daeeqns;
      
              array<list<Integer>> mapEqnIncRow;
      
              array<Integer> mapIncRowEqn;
      
              BackendDAE.IndexType indexType;
      
              Boolean scalar, processed;
      
            case BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=daeeqns, m=SOME(m), mT=SOME(mt), mapping=SOME((_, _, indexType, scalar, processed)))
      
              algorithm
      
                // extend the mapping arrays
      
                oldsize := arrayLength(iMapEqnIncRow);
      
        2180
                newsize := BackendEquation.getNumberOfEquations(daeeqns);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2180 times.

        2180
                mapEqnIncRow := Array.expand(newsize-oldsize, iMapEqnIncRow, {});
      
                oldsize1 := arrayLength(iMapIncRowEqn);
      
        2180
                newsize1 := BackendEquation.equationArraySize(daeeqns);
      
        2180
                deltasize := newsize1-oldsize1;
      
        2180
                mapIncRowEqn := Array.expand(deltasize, iMapIncRowEqn, 0);
      
                // extend the adjacencyMatrix
      
        2180
                m := Array.expand(deltasize, m, {});
      
        2180
                mt := Array.expand(deltasize, mt, {});
      
                // fill the extended parts first
      
        2180
                (m, mt, mapEqnIncRow, mapIncRowEqn) :=
      
                    updateAdjacencyMatrixScalar2( oldsize+1, newsize, oldsize1, vars, daeeqns, m, mt, mapEqnIncRow,
      
                                                  mapIncRowEqn, inIndxType, functionTree, isInitial);
      
                // update the old
      
        2180
                eqns := List.removeOnTrue(oldsize, intLt, inIntegerLst);
      
        2180
                (m,mt,mapEqnIncRow,mapIncRowEqn) :=
      
                    updateAdjacencyMatrixScalar1( vars, daeeqns, m, mt, eqns, mapEqnIncRow,
      
                                                  mapIncRowEqn, inIndxType, functionTree, isInitial);
      
          5/6✓ Branch 0 taken 12 times.
✓ Branch 1 taken 2168 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2180 times.
✓ Branch 7 taken 2179 times.
✓ Branch 8 taken 1 time.

        6552
              then
      
                (BackendDAEUtil.setEqSystMatrices(syst, SOME(m), SOME(mt), SOME((mapEqnIncRow, mapIncRowEqn, indexType, scalar, processed))), mapEqnIncRow, mapIncRowEqn);
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"BackendDAEUtil.updateAdjacencyMatrixScalar failed"});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end updateAdjacencyMatrixScalar;
      
        protected function updateAdjacencyMatrixScalar1
      
          "Helper"
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.EquationArray daeeqns;
      
          input BackendDAE.AdjacencyMatrix m;
      
          input BackendDAE.AdjacencyMatrixT mt;
      
          input list<Integer> inIntegerLst;
      
          input array<list<Integer>> iMapEqnIncRow;
      
          input array<Integer> iMapIncRowEqn;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
          output array<list<Integer>> oMapEqnIncRow;
      
          output array<Integer> oMapIncRowEqn;
      
        algorithm
      
          (outAdjacencyMatrix,outAdjacencyMatrixT,oMapEqnIncRow,oMapIncRowEqn):=
      
          match inIntegerLst
      
            local
      
              BackendDAE.AdjacencyMatrix m_1,m_2;
      
              BackendDAE.AdjacencyMatrixT mt_1,mt_2,mt_3;
      
              Integer e,abse;
      
              BackendDAE.Equation eqn;
      
              AvlSetInt.Tree invarsTree,outvarsTree;
      
              list<Integer> row,invars,outvars,eqns,oldvars,scalarindxs;
      
              array<list<Integer>> mapEqnIncRow;
      
              array<Integer> mapIncRowEqn;
      
            case {} then (m,mt,iMapEqnIncRow,iMapIncRowEqn);
      
            case e::eqns guard(BackendEquation.has(daeeqns, intAbs(e)))
      
              algorithm
      
                abse := intAbs(e);
      
        13156
                eqn := BackendEquation.get(daeeqns, abse);
      
        13156
                (row,_) := adjacencyRow(eqn,vars,inIndxType,functionTree,{},isInitial);
      
        13156
                row := uniqueRow(row);
      
        13156
                scalarindxs := iMapEqnIncRow[abse];
      
        13156
                oldvars := getOldVars(m,listHead(scalarindxs));
      
        13156
                (_,outvarsTree,invarsTree) := AvlSetInt.intersection(AvlSetInt.addList(AvlSetInt.EMPTY(), oldvars), AvlSetInt.addList(AvlSetInt.EMPTY(), row));
      
        13156
                outvars := AvlSetInt.listKeys(outvarsTree);
      
        13156
                invars := AvlSetInt.listKeys(invarsTree);
      
                // do the same for each scalar indxs
      
        13156
                m_1 := List.fold1r(scalarindxs,arrayUpdate,row,m);
      
        13156
                mt_1 := List.fold1(scalarindxs,removeValuefromMatrix,outvars,mt);
      
        13156
                mt_2 := List.fold1(scalarindxs,addValuetoMatrix,invars,mt_1);
      
        13156
                (m_2,mt_3,mapEqnIncRow,mapIncRowEqn) := updateAdjacencyMatrixScalar1(vars,daeeqns,m_1,mt_2,eqns,iMapEqnIncRow,iMapIncRowEqn,inIndxType,functionTree,isInitial);
      
              then (m_2,mt_3,mapEqnIncRow,mapIncRowEqn);
      
            case e::eqns // Backup for non existent equations
      
              algorithm
      
        ✗
                abse := intAbs(e);
      
                row := {};
      
        ✗
                scalarindxs := iMapEqnIncRow[abse];
      
        ✗
                oldvars := getOldVars(m,listHead(scalarindxs));
      
        ✗
                (_,outvarsTree,invarsTree) := AvlSetInt.intersection(AvlSetInt.addList(AvlSetInt.EMPTY(), oldvars), AvlSetInt.EMPTY());
      
        ✗
                outvars := AvlSetInt.listKeys(outvarsTree);
      
        ✗
                invars := AvlSetInt.listKeys(invarsTree);
      
                // do the same for each scalar indxs
      
        ✗
                m_1 := List.fold1r(scalarindxs,arrayUpdate,row,m);
      
        ✗
                mt_1 := List.fold1(scalarindxs,removeValuefromMatrix,outvars,mt);
      
        ✗
                mt_2 := List.fold1(scalarindxs,addValuetoMatrix,invars,mt_1);
      
        ✗
                (m_2,mt_3,mapEqnIncRow,mapIncRowEqn) := updateAdjacencyMatrixScalar1(vars,daeeqns,m_1,mt_2,eqns,iMapEqnIncRow,iMapIncRowEqn,inIndxType,functionTree,isInitial);
      
              then (m_2,mt_3,mapEqnIncRow,mapIncRowEqn);
      
          end match;
      
        end updateAdjacencyMatrixScalar1;
      
        protected function updateAdjacencyMatrixScalar2
      
          "Helper"
      
          input Integer index;
      
          input Integer n;
      
          input Integer size;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.EquationArray daeeqns;
      
          input BackendDAE.AdjacencyMatrix m;
      
          input BackendDAE.AdjacencyMatrixT mt;
      
          input array<list<Integer>> iMapEqnIncRow;
      
          input array<Integer> iMapIncRowEqn;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
          output array<list<Integer>> oMapEqnIncRow;
      
          output array<Integer> oMapIncRowEqn;
      
        algorithm
      
          (outAdjacencyMatrix,outAdjacencyMatrixT,oMapEqnIncRow,oMapIncRowEqn):=
      
          matchcontinue functionTree
      
            local
      
              BackendDAE.AdjacencyMatrix m1;
      
              BackendDAE.AdjacencyMatrixT mt1;
      
              Integer abse,rowsize,new_size;
      
              BackendDAE.Equation eqn;
      
              list<Integer> row;
      
              list<Integer> scalarindxs, row_lst;
      
              array<list<Integer>> mapEqnIncRow;
      
              array<Integer> mapIncRowEqn;
      
            case _
      
              guard(not intGt(index,n) and BackendEquation.has(daeeqns, intAbs(index)))
      
              algorithm
      
                abse := intAbs(index);
      
        ✗
                eqn := BackendEquation.get(daeeqns, abse);
      
        ✗
                rowsize := BackendEquation.equationSize(eqn);
      
        ✗
                (row,_) := adjacencyRow(eqn,vars,inIndxType,functionTree,{},isInitial);
      
        ✗
                new_size := size+rowsize;
      
        ✗
                scalarindxs := List.intRange2(size+1,new_size);
      
        ✗
                mapEqnIncRow := arrayUpdate(iMapEqnIncRow,abse,scalarindxs);
      
        ✗
                mapIncRowEqn := List.fold1r(scalarindxs,arrayUpdate,abse,iMapIncRowEqn);
      
        ✗
                row_lst := uniqueRow(row);
      
        ✗
                m1:= List.fold1r(scalarindxs,arrayUpdate,row_lst,m);
      
        ✗
                mt1 := filladjacencyMatrixT(row_lst,scalarindxs,mt);
      
        ✗
                (m1,mt1,mapEqnIncRow,mapIncRowEqn) := updateAdjacencyMatrixScalar2(index+1,n,new_size,vars,daeeqns,m1,mt1,mapEqnIncRow,mapIncRowEqn,inIndxType,functionTree,isInitial);
      
              then
      
                (m1,mt1,mapEqnIncRow,mapIncRowEqn);
      
            case _
      
        2180
              then
      
                (m,mt,iMapEqnIncRow,iMapIncRowEqn);
      
            else
      
              algorithm
      
        ✗
                abse := intAbs(index);
      
                rowsize := 1;
      
                row := {};
      
        ✗
                new_size := size+rowsize;
      
        ✗
                scalarindxs := List.intRange2(size+1,new_size);
      
        ✗
                mapEqnIncRow := arrayUpdate(iMapEqnIncRow,abse,scalarindxs);
      
        ✗
                mapIncRowEqn := List.fold1r(scalarindxs,arrayUpdate,abse,iMapIncRowEqn);
      
        ✗
                row_lst := uniqueRow(row);
      
        ✗
                m1:= List.fold1r(scalarindxs,arrayUpdate,row_lst,m);
      
        ✗
                mt1 := filladjacencyMatrixT(row_lst,scalarindxs,mt);
      
        ✗
                (m1,mt1,mapEqnIncRow,mapIncRowEqn) := updateAdjacencyMatrixScalar2(index+1,n,new_size,vars,daeeqns,m1,mt1,mapEqnIncRow,mapIncRowEqn,inIndxType,functionTree,isInitial);
      
              then
      
                (m1,mt1,mapEqnIncRow,mapIncRowEqn);
      
          end matchcontinue;
      
        end updateAdjacencyMatrixScalar2;
      
        protected function getOldVars
      
          input array<list<Integer>> m;
      
          input Integer pos;
      
          output  list<Integer> oldvars;
      
        algorithm
      
          1/2✓ Branch 0 taken 44726 times.
✗ Branch 1 not taken.

        44726
          oldvars := if pos <= arrayLength(m) then m[pos] else {};
      
        end getOldVars;
      
        protected function removeValuefromMatrix
      
        "author: Frenkel TUD 2011-04"
      
          input Integer inValue;
      
          input list<Integer> inIntegerLst;
      
          input BackendDAE.AdjacencyMatrixT inAdjacencyMatrixT;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
        algorithm
      
          outAdjacencyMatrixT:=
      
          matchcontinue (inValue,inIntegerLst,inAdjacencyMatrixT)
      
            local
      
              BackendDAE.AdjacencyMatrixT mt,mt_1,mt_2;
      
              BackendDAE.AdjacencyMatrixElement mlst,mlst1;
      
              list<Integer> keys;
      
              Integer k,kabs;
      
              Integer v,v_1;
      
            case (_,{},mt) then mt;
      
            case (v,k::keys,mt)
      
              algorithm
      
        15439
                kabs := intAbs(k);
      
        15439
                mlst := mt[kabs];
      
          2/2✓ Branch 0 taken 4123 times.
✓ Branch 1 taken 11316 times.

        15439
                v_1 := if intGt(k,0) then v else -v;
      
        15439
                mlst1 := List.removeOnTrue(v_1,intEq,mlst);
      
        15439
                mt_1 := arrayUpdate(mt, kabs , mlst1);
      
        15439
                mt_2 := removeValuefromMatrix(v,keys,mt_1);
      
              then
      
                mt_2;
      
            case (v,_::keys,mt)
      
              algorithm
      
        ✗
                mt_2 := removeValuefromMatrix(v,keys,mt);
      
              then
      
                mt_2;
      
            case (_,_,_)
      
              algorithm
      
        ✗
                print("- BackendDAE.removeValuefromMatrix failed\n");
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end removeValuefromMatrix;
      
        protected function addValuetoMatrix
      
        "author: Frenkel TUD 2011-04"
      
          input Integer inValue;
      
          input list<Integer> inIntegerLst;
      
          input BackendDAE.AdjacencyMatrixT inAdjacencyMatrixT;
      
          output BackendDAE.AdjacencyMatrixT outAdjacencyMatrixT;
      
        algorithm
      
          outAdjacencyMatrixT:=
      
          matchcontinue (inValue,inIntegerLst,inAdjacencyMatrixT)
      
            local
      
              BackendDAE.AdjacencyMatrixT mt,mt_1,mt_2;
      
              BackendDAE.AdjacencyMatrixElement mlst;
      
              list<Integer> keys;
      
              Integer k,kabs;
      
              Integer v,v_1;
      
            case (_,{},mt) then mt;
      
            case (v,k::keys,mt)
      
              algorithm
      
        29266
                kabs := intAbs(k);
      
        29266
                mlst := getOldVars(mt,kabs);
      
          2/2✓ Branch 0 taken 20135 times.
✓ Branch 1 taken 9131 times.

        29266
                v_1 := if intGt(k,0) then v else -v;
      
          2/2✓ Branch 1 taken 24 times.
✓ Branch 2 taken 29242 times.

        29266
                false := listMember(v_1, mlst);
      
        29242
                mt_1 := Array.replaceAtWithFill(kabs,v_1::mlst,{},mt);
      
        29242
                mt_2 := addValuetoMatrix(v,keys,mt_1);
      
              then
      
                mt_2;
      
            case (v,_::keys,mt)
      
              algorithm
      
        24
                mt_2 := addValuetoMatrix(v,keys,mt);
      
              then
      
                mt_2;
      
            case (_,_,_)
      
              algorithm
      
        ✗
                print("- BackendDAE.addValuetoMatrix failed\n");
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end addValuetoMatrix;
      
        public function getAdjacencyMatrixfromOptionForMapEqSystem "function getAdjacencyMatrixfromOption"
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.IndexType inIndxType;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.EqSystem osyst;
      
          output BackendDAE.Shared oshared;
      
        protected
      
          AvlTreePathFunction.Tree funcs;
      
        algorithm
      
        28
          funcs := getFunctions(shared);
      
        56
          (osyst,_,_) := getAdjacencyMatrixfromOption(syst, inIndxType,SOME(funcs), BackendDAEUtil.isInitializationDAE(shared));
      
          oshared := shared;
      
        end getAdjacencyMatrixfromOptionForMapEqSystem;
      
        public function getAdjacencyMatrixfromOption
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> inFunctionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.EqSystem outSyst;
      
          output BackendDAE.AdjacencyMatrix outM;
      
          output BackendDAE.AdjacencyMatrix outMT;
      
        algorithm
      
          (outSyst, outM, outMT) := match inSyst
      
            local
      
              BackendDAE.AdjacencyMatrix m, mT;
      
              BackendDAE.Variables v;
      
              BackendDAE.AdjacencyMatrixMapping mapping;
      
            case BackendDAE.EQSYSTEM(m=NONE()) algorithm
      
        73924
              (m, mT) := adjacencyMatrix(inSyst, inIndxType, inFunctionTree, isInitial);
      
        73924
              mapping := getArrayAdjacencyMatrixMapping(ExpandableArray.getNumberOfElements(inSyst.orderedEqs), inIndxType, false);
      
        147848
            then (BackendDAEUtil.setEqSystMatrices(inSyst, SOME(m), SOME(mT), SOME(mapping)), m, mT);
      
            case BackendDAE.EQSYSTEM(orderedVars=v, m=SOME(m), mT=NONE(), mapping=NONE()) algorithm
      
        ✗
              mT := AdjacencyMatrix.transposeAdjacencyMatrix(m, BackendVariable.varsSize(v));
      
        ✗
            then (BackendDAEUtil.setEqSystMatrices(inSyst, SOME(m), SOME(mT), NONE()), m, mT);
      
            case BackendDAE.EQSYSTEM(orderedVars=v, m=SOME(m), mT=NONE(), mapping=SOME(mapping)) algorithm
      
        ✗
              mT := AdjacencyMatrix.transposeAdjacencyMatrix(m, BackendVariable.varsSize(v));
      
        ✗
            then (BackendDAEUtil.setEqSystMatrices(inSyst, SOME(m), SOME(mT), SOME(mapping)), m, mT);
      
            case BackendDAE.EQSYSTEM(m=SOME(m), mT=SOME(mT))
      
            then (inSyst, m, mT);
      
          end match;
      
        end getAdjacencyMatrixfromOption;
      
        public function getArrayAdjacencyMatrixMapping
      
        "author: kabdelhak FHB 10-2019
      
         Returns an identity mapping for array adjacency matrices."
      
          input Integer size;
      
          input BackendDAE.IndexType indexType;
      
          input Boolean scalar;
      
          output BackendDAE.AdjacencyMatrixMapping mapping;
      
        protected
      
          array<list<Integer>> mapEqnIncRow = arrayCreate(size, {-1});
      
          array<Integer> mapIncRowEqn = arrayCreate(size, -1);
      
        algorithm
      
          2/2✓ Branch 0 taken 86413 times.
✓ Branch 1 taken 1983 times.

        1000573
          for i in 1:size loop
      
        912177
            mapEqnIncRow[i] := {i};
      
        912177
            mapIncRowEqn[i] := i;
      
          end for;
      
          1/2✓ Branch 0 taken 88396 times.
✗ Branch 1 not taken.

        176792
          mapping := (mapEqnIncRow, mapIncRowEqn, indexType, scalar, false);
      
        end getArrayAdjacencyMatrixMapping;
      
        public function getAdjacencyMatrix "this function returns the adjacency matrix,
      
          if the system contains multidimensional equations and the scalar one is needed use getAdjacencyMatrixScalar"
      
          input BackendDAE.EqSystem inEqSystem;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.EqSystem outEqSystem;
      
          output BackendDAE.AdjacencyMatrix outM;
      
          output BackendDAE.AdjacencyMatrix outMT;
      
        protected
      
          BackendDAE.AdjacencyMatrixMapping mapping;
      
        algorithm
      
        14472
          (outM, outMT) := adjacencyMatrix(inEqSystem, inIndxType, functionTree, isInitial);
      
        14472
          mapping := getArrayAdjacencyMatrixMapping(ExpandableArray.getNumberOfElements(inEqSystem.orderedEqs), inIndxType, false);
      
        28944
          outEqSystem := BackendDAEUtil.setEqSystMatrices(inEqSystem, SOME(outM), SOME(outMT), SOME(mapping));
      
        end getAdjacencyMatrix;
      
        public function getAdjacencyMatrixScalar "function getAdjacencyMatrixScalar"
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> functionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.EqSystem osyst;
      
          output BackendDAE.AdjacencyMatrix outM;
      
          output BackendDAE.AdjacencyMatrix outMT;
      
          output array<list<Integer>> outMapEqnIncRow;
      
          output array<Integer> outMapIncRowEqn;
      
        algorithm
      
        223112
          (outM, outMT, outMapEqnIncRow, outMapIncRowEqn) := adjacencyMatrixScalar(syst, inIndxType, functionTree, isInitial);
      
        669336
          osyst := BackendDAEUtil.setEqSystMatrices(syst, SOME(outM), SOME(outMT), SOME((outMapEqnIncRow, outMapIncRowEqn, inIndxType, true, false)));
      
        end getAdjacencyMatrixScalar;
      
        public function removedAdjacencyMatrix
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.IndexType inIndxType;
      
          input Option<AvlTreePathFunction.Tree> inFunctionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outM;
      
          output BackendDAE.AdjacencyMatrix outMT;
      
        algorithm
      
        2454
          (outM, outMT) := adjacencyMatrixDispatch(inSyst.orderedVars, inSyst.removedEqs, inIndxType, inFunctionTree, isInitial);
      
        end removedAdjacencyMatrix;
      
        public function removedAdjacencyMatrixMasked
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.IndexType inIndxType;
      
          input array<Boolean> inMask;
      
          input Option<AvlTreePathFunction.Tree> inFunctionTree;
      
          input Boolean isInitial;
      
          output BackendDAE.AdjacencyMatrix outM;
      
          output BackendDAE.AdjacencyMatrix outMT;
      
        algorithm
      
        ✗
          (outM, outMT) := adjacencyMatrixDispatchMasked(inSyst.orderedVars, inSyst.removedEqs, inIndxType, inMask, inFunctionTree, isInitial);
      
        end removedAdjacencyMatrixMasked;
      
        protected function traverseStmts<ArgT> "Author: Frenkel TUD 2012-06
      
          traverese DAE.Statement without change possibility."
      
          input list<DAE.Statement> inStmts;
      
          input FuncExpType func;
      
          input output ArgT extraArg;
      
          partial function FuncExpType
      
             input DAE.Exp arg1;
      
             input output ArgT arg2;
      
          end FuncExpType;
      
        protected
      
          DAE.Exp e,e2;
      
          list<DAE.Exp> expl1;
      
          DAE.ComponentRef cr;
      
          list<DAE.Statement> stmts;
      
          DAE.Type tp;
      
          DAE.Statement ew;
      
          String id1,str;
      
          DAE.Else algElse;
      
        algorithm
      
          2/2✓ Branch 0 taken 47432 times.
✓ Branch 1 taken 22542 times.

        69974
          for stmt in inStmts loop
      
            extraArg := matchcontinue stmt
      
              case DAE.STMT_ASSIGN(exp1 = e2,exp = e)
      
                algorithm
      
                  // kabdelhak: remove left hand side subscripts
      
                  // (Modelica Specification v3.5 : 11.1.2)
      
                  // solves ticket #7832
      
          1/2✓ Branch 0 taken 30254 times.
✗ Branch 1 not taken.

        30254
                  extraArg := func(e, extraArg);
      
          1/2✓ Branch 0 taken 30254 times.
✗ Branch 1 not taken.

        30254
                  extraArg := func(e2, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_TUPLE_ASSIGN(expExpLst = expl1, exp = e)
      
                algorithm
      
                  // kabdelhak: remove left hand side subscripts
      
                  // (Modelica Specification v3.5 : 11.1.2)
      
                  // solves ticket #7832
      
          1/2✓ Branch 0 taken 279 times.
✗ Branch 1 not taken.

        279
                  extraArg := func(e, extraArg);
      
        279
                  extraArg := List.fold(expl1,func,extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_ASSIGN_ARR(lhs = e2, exp = e)
      
                algorithm
      
                  // kabdelhak: remove left hand side subscripts
      
                  // (Modelica Specification v3.5 : 11.1.2)
      
                  // solves ticket #7832
      
          1/2✓ Branch 0 taken 1264 times.
✗ Branch 1 not taken.

        1264
                  extraArg := func(e, extraArg);
      
          1/2✓ Branch 0 taken 1264 times.
✗ Branch 1 not taken.

        1264
                  extraArg := func(e2, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_IF(exp=e,statementLst=stmts,else_ = algElse)
      
                algorithm
      
        5141
                  extraArg := traverseStmtsElse(algElse,func,extraArg);
      
        5141
                  extraArg := traverseStmts(stmts,func,extraArg);
      
          1/2✓ Branch 0 taken 5141 times.
✗ Branch 1 not taken.

        5141
                  extraArg := func(e, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_FOR(type_=tp,iter=id1,range=e,statementLst=stmts)
      
                algorithm
      
          1/2✓ Branch 0 taken 2776 times.
✗ Branch 1 not taken.

        2776
                  extraArg := func(e, extraArg);
      
        2776
                  cr := ComponentReferenceBasics.makeCrefIdent(id1, tp, {});
      
        2776
                  (stmts,_) := DAEUtil.traverseDAEEquationsStmts(stmts,Expression.traverseSubexpressionsHelper,(Expression.replaceCref,(cr,e)));
      
        2776
                  extraArg := traverseStmts(stmts,func,extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_PARFOR(type_=tp,iter=id1,range=e,statementLst=stmts)
      
                algorithm
      
        ✗
                  extraArg := func(e, extraArg);
      
        ✗
                  cr := ComponentReferenceBasics.makeCrefIdent(id1, tp, {});
      
        ✗
                  (stmts,_) := DAEUtil.traverseDAEEquationsStmts(stmts,Expression.traverseSubexpressionsHelper,(Expression.replaceCref,(cr,e)));
      
        ✗
                  extraArg := traverseStmts(stmts,func,extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_WHILE(exp=e,statementLst=stmts)
      
                algorithm
      
        ✗
                  extraArg := traverseStmts(stmts,func,extraArg);
      
        ✗
                  extraArg := func(e, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_WHEN(exp=e,statementLst=stmts,elseWhen=NONE())
      
                algorithm
      
        1914
                  extraArg := traverseStmts(stmts,func,extraArg);
      
          1/2✓ Branch 0 taken 1914 times.
✗ Branch 1 not taken.

        1914
                  extraArg := func(e, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_WHEN(exp=e,statementLst=stmts,elseWhen=SOME(ew))
      
                algorithm
      
        775
                  extraArg := traverseStmts({ew},func,extraArg);
      
        775
                  extraArg := traverseStmts(stmts,func,extraArg);
      
          1/2✓ Branch 0 taken 775 times.
✗ Branch 1 not taken.

        775
                  extraArg := func(e, extraArg);
      
                then
      
                  extraArg;
      
              case DAE.STMT_ASSERT(cond = e, msg=e2)
      
                algorithm
      
          1/2✓ Branch 0 taken 3903 times.
✗ Branch 1 not taken.

        3903
                  extraArg := func(e, extraArg);
      
          1/2✓ Branch 0 taken 3903 times.
✗ Branch 1 not taken.

        3903
                  extraArg := func(e2, extraArg);
      
                then
      
                  extraArg;
      
          1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

        4
              case DAE.STMT_TERMINATE(msg = e) then func(e, extraArg);
      
              case DAE.STMT_REINIT(var = e,value=e2)
      
                algorithm
      
          1/2✓ Branch 0 taken 364 times.
✗ Branch 1 not taken.

        364
                  extraArg := func(e, extraArg);
      
          1/2✓ Branch 0 taken 364 times.
✗ Branch 1 not taken.

        364
                  extraArg := func(e2, extraArg);
      
                then
      
                  extraArg;
      
          1/2✓ Branch 0 taken 450 times.
✗ Branch 1 not taken.

        450
              case DAE.STMT_NORETCALL(exp = e) then func(e, extraArg);
      
        ✗
              case DAE.STMT_RETURN() then extraArg;
      
        308
              case DAE.STMT_BREAK() then extraArg;
      
        ✗
              case DAE.STMT_CONTINUE() then extraArg;
      
              // MetaModelica extension. KS
      
              case DAE.STMT_FAILURE(body=stmts)
      
        ✗
                then traverseStmts(stmts,func,extraArg);
      
              else
      
                algorithm
      
        ✗
                  str := DAEDump.ppStatementStr(stmt);
      
        ✗
                  str := "BackenddAEUtil.traverseStmts not implemented correctly: " + str;
      
        ✗
                  Error.addMessage(Error.INTERNAL_ERROR, {str});
      
        ✗
                then fail();
      
            end matchcontinue;
      
          end for;
      
        end traverseStmts;
      
        protected function traverseStmtsElse "
      
        Author: Frenkel TUD 2012-06
      
        Helper function for traverseStmts
      
        "
      
          input DAE.Else inElse;
      
          input FuncExpType func;
      
          input Type_a iextraArg;
      
          output Type_a oextraArg;
      
          partial function FuncExpType
      
            input DAE.Exp arg1;
      
            input output Type_a arg2;
      
          end FuncExpType;
      
          replaceable type Type_a subtypeof Any;
      
        algorithm
      
          oextraArg := match(inElse, iextraArg)
      
            local
      
              DAE.Exp e;
      
              list<DAE.Statement> st;
      
              DAE.Else el;
      
              Type_a extraArg;
      
            case (DAE.NOELSE(), extraArg) then extraArg;
      
            case (DAE.ELSEIF(e,st,el), extraArg)
      
              algorithm
      
        1622
                extraArg := traverseStmtsElse(el,func,extraArg);
      
          1/2✓ Branch 0 taken 1622 times.
✗ Branch 1 not taken.

        1622
                extraArg := func(e, extraArg);
      
        1622
              then
      
                traverseStmts(st,func,extraArg);
      
            case(DAE.ELSE(st), extraArg)
      
        825
              then
      
                traverseStmts(st,func,extraArg);
      
          end match;
      
        end traverseStmtsElse;
      
        public function adjacencyMatrixToSparsePattern
      
        " Applies absolute value to all entries in the adjacency matrix and
      
          also sort and unique them."
      
          input BackendDAE.AdjacencyMatrix m;
      
          output BackendDAE.AdjacencyMatrix res;
      
        protected
      
          list<list<Integer>> lst,lst_1;
      
        algorithm
      
        ✗
          lst := arrayList(m);
      
        ✗
          lst_1 := List.mapList(lst, intAbs);
      
        ✗
          lst_1 := List.map1(lst_1, List.sort, intGt);
      
        ✗
          lst_1 := List.map1(lst_1, List.sortedUnique, intGe);
      
        ✗
          res := listArray(lst_1);
      
        end adjacencyMatrixToSparsePattern;
      
        /******************************************************************
      
         stuff to calculate enhanced Adjacency matrix
      
         The Adjacency matrix describes the relation between knots and
      
         knots of a bigraph. Additional information about the solvability
      
         of a variable are available.
      
        ******************************************************************/
      
        public function getAdjacencyMatrixEnhancedScalar
      
        "author: Frenkel TUD 2012-05
      
          Calculates the Adjacency matrix, i.e. which variables are present in each equation
      
          and add some information how the variable occur in the equation(see BackendDAE.BackendDAE.Solvability)."
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.Shared shared;
      
          input Boolean trytosolve "determine the solvability by solving for the variable instead of deriving, needed for 'Casual Tearing Set'";
      
          output BackendDAE.AdjacencyMatrixEnhanced outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixTEnhanced outAdjacencyMatrixT;
      
          output array<list<Integer>> outMapEqnIncRow;
      
          output array<Integer> outMapIncRowEqn;
      
        protected
      
          list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTupleList;
      
        algorithm
      
          (outAdjacencyMatrix,outAdjacencyMatrixT,outMapEqnIncRow,outMapIncRowEqn) :=
      
          matchcontinue (syst, shared)
      
            local
      
              BackendDAE.AdjacencyMatrixEnhanced arr;
      
              BackendDAE.AdjacencyMatrixTEnhanced arrT;
      
              BackendDAE.Variables vars,globalKnownVars;
      
              BackendDAE.EquationArray eqns;
      
              Integer numberOfEqs,numberofVars;
      
              array<Integer> rowmark "array to mark if a variable is allready found in the equation, and to mark if it is unsolvable(marked negative) in the equation";
      
              array<list<Integer>> mapEqnIncRow;
      
              array<Integer> mapIncRowEqn;
      
            case (BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = eqns), BackendDAE.SHARED(globalKnownVars=globalKnownVars))
      
              algorithm
      
                // get the size
      
        2494
                numberOfEqs := BackendEquation.getNumberOfEquations(eqns);
      
        2494
                numberofVars := BackendVariable.varsSize(vars);
      
                // create the array to hold the Adjacency matrix
      
        2494
                 arrT := arrayCreate(numberofVars, {});
      
                // create the array to mark if a variable is allready found in the equation
      
        2494
                rowmark := arrayCreate(numberofVars, 0);
      
        2494
                (arr,arrT,mapEqnIncRow,mapIncRowEqn,varsSolvedInWhenEqnsTupleList) := adjacencyMatrixDispatchEnhancedScalar(vars, eqns,arrT, numberOfEqs, rowmark,globalKnownVars ,trytosolve, shared);
      
        2494
              then
      
                (arr,arrT,mapEqnIncRow,mapIncRowEqn);
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"BackendDAEUtil.getAdjacencyMatrixEnhancedScalar failed"});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        2494
          makeWhenEqnVarsUnsolvable(outAdjacencyMatrix,outAdjacencyMatrixT,varsSolvedInWhenEqnsTupleList);
      
        end getAdjacencyMatrixEnhancedScalar;
      
        function makeWhenEqnVarsUnsolvable
      
         "Function to make variables solved in when-equations unsolvable in all other equations.
      
          author: ptaeuber FHB"
      
          input BackendDAE.AdjacencyMatrixEnhanced m;
      
          input BackendDAE.AdjacencyMatrixTEnhanced mt;
      
          input list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTupleList;
      
        protected
      
          Integer eqn;
      
          list<Integer> vars,eqns;
      
          BackendDAE.AdjacencyMatrixElementEnhanced adjacencyRow;
      
          BackendDAE.AdjacencyMatrixElementEnhanced adjacencyRowT;
      
        algorithm
      
          2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2494 times.

        2501
          for tpl in varsSolvedInWhenEqnsTupleList loop
      
        7
            (eqn,vars) := tpl;
      
          2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 7 times.

        14
            for var in vars loop
      
              // update m
      
        7
              adjacencyRowT := mt[var];
      
          4/4✓ Branch 0 taken 14 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 7 times.

        21
              eqns := list(
      
                match adjacencyElemT
      
                  local
      
                    Integer i;
      
                  case(i,_,_) then i;
      
                end match for adjacencyElemT in adjacencyRowT);
      
        7
              eqns := List.deleteMemberOnTrue(eqn,eqns,intEq);
      
          2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 7 times.

        14
              for e in eqns loop
      
        7
                adjacencyRow := m[e];
      
          4/4✓ Branch 0 taken 19 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 19 times.
✓ Branch 3 taken 7 times.

        26
                adjacencyRow := list(
      
                match adjacencyElem
      
                  local
      
                    Integer i;
      
                    BackendDAE.Constraints c;
      
        7
                  case (i,_,c) guard intEq(i,var) then (i,BackendDAE.SOLVABILITY_UNSOLVABLE(),c);
      
                  case (_,_,_) then (adjacencyElem);
      
                end match for adjacencyElem in adjacencyRow);
      
        7
                arrayUpdate(m,e,adjacencyRow);
      
              end for;
      
              // update mt
      
        7
              adjacencyRowT := mt[var];
      
          4/4✓ Branch 0 taken 14 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 7 times.

        21
              adjacencyRowT := list(
      
                match adjacencyElemT
      
                  local
      
                    Integer i;
      
                    BackendDAE.Constraints c;
      
        7
                  case (i,_,c) guard not intEq(i,eqn) then (i,BackendDAE.SOLVABILITY_UNSOLVABLE(),c);
      
                  case (_,_,_) then (adjacencyElemT);
      
                end match for adjacencyElemT in adjacencyRowT);
      
        7
            arrayUpdate(mt,var,adjacencyRowT);
      
            end for;
      
          end for;
      
        end makeWhenEqnVarsUnsolvable;
      
        protected function adjacencyMatrixDispatchEnhancedScalar
      
        "@author: Frenkel TUD 2012-05
      
          Calculates the adjacency matrix and the transposed
      
          adjacency matrix."
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.EquationArray eqArr;
      
          output BackendDAE.AdjacencyMatrixEnhanced outAdjacencyArray;
      
          input output BackendDAE.AdjacencyMatrixTEnhanced adjacencyArrayT;
      
          input Integer numberOfEqs;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Boolean trytosolve;
      
          input BackendDAE.Shared shared;
      
          output array<list<Integer>> omapEqnIncRow;
      
          output array<Integer> omapIncRowEqn;
      
          output list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTupleListOut = {};
      
        protected
      
          list<BackendDAE.AdjacencyMatrixElementEnhanced> inAdjacencyArray = {};
      
          list<list<Integer>> mapEqnIncRow = {};
      
          list<Integer> imapIncRowEqn = {};
      
          BackendDAE.Equation e;
      
          BackendDAE.AdjacencyMatrixElementEnhanced row;
      
          Integer size, rowSize = 0;
      
          list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTuple;
      
          list<Integer> rowindxs;
      
        algorithm
      
          1/2✓ Branch 0 taken 2494 times.
✗ Branch 1 not taken.

        49994
          for i1 in 1:numberOfEqs loop
      
            // get the equation
      
        47500
            e := BackendEquation.get(eqArr, i1);
      
            // compute the row
      
        47500
            (row,size,varsSolvedInWhenEqnsTuple) := adjacencyRowEnhanced(vars, e, i1, rowmark, globalKnownVars, trytosolve, shared);
      
        47500
            rowindxs := List.intRange2(rowSize+1, rowSize+size);
      
        47500
            rowSize := rowSize + size;
      
        47500
            imapIncRowEqn := List.consN(size,i1,imapIncRowEqn);
      
            // put it in the arrays
      
        47500
            inAdjacencyArray := List.consN(size,row,inAdjacencyArray);
      
        47500
            adjacencyArrayT := fillincAdjacencyMatrixTEnhanced(row,rowindxs,adjacencyArrayT);
      
        47500
            varsSolvedInWhenEqnsTupleListOut := listAppend(varsSolvedInWhenEqnsTuple, varsSolvedInWhenEqnsTupleListOut);
      
            mapEqnIncRow := rowindxs::mapEqnIncRow;
      
          end for;
      
        2494
          outAdjacencyArray := List.listArrayReverse(inAdjacencyArray);
      
        2494
          omapEqnIncRow := List.listArrayReverse(mapEqnIncRow);
      
        2494
          omapIncRowEqn := List.listArrayReverse(imapIncRowEqn);
      
        end adjacencyMatrixDispatchEnhancedScalar;
      
        public function getAdjacencyMatrixEnhanced
      
        "author: Frenkel TUD 2012-05
      
          Calculates the Adjacency matrix, i.e. which variables are present in each equation
      
          and add some information how the variable occure in the equation(see BackendDAE.BackendDAE.Solvability)."
      
          input BackendDAE.EqSystem syst;
      
          input BackendDAE.Shared shared;
      
          input Boolean trytosolve;
      
          output BackendDAE.AdjacencyMatrixEnhanced outAdjacencyMatrix;
      
          output BackendDAE.AdjacencyMatrixTEnhanced outAdjacencyMatrixT;
      
        algorithm
      
          (outAdjacencyMatrix,outAdjacencyMatrixT) := matchcontinue (syst, shared)
      
            local
      
              BackendDAE.AdjacencyMatrixEnhanced arr;
      
              BackendDAE.AdjacencyMatrixTEnhanced arrT;
      
              BackendDAE.Variables vars,globalKnownVars;
      
              BackendDAE.EquationArray eqns;
      
              Integer numberOfEqs,numberofVars;
      
              array<Integer> rowmark "array to mark if a variable is allready found in the equation, and to mark if it is unsolvable(marked negative) in the equation";
      
            case (BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = eqns), BackendDAE.SHARED(globalKnownVars=globalKnownVars))
      
              algorithm
      
                // get the size
      
        34
                numberOfEqs := BackendEquation.getNumberOfEquations(eqns);
      
        34
                numberofVars := BackendVariable.varsSize(vars);
      
                // create the array to hold the Adjacency matrix
      
        34
                arr := arrayCreate(BackendEquation.equationArraySize(eqns), {});
      
        34
                arrT := arrayCreate(numberofVars, {});
      
                // create the array to mark if a variable is allready found in the equation
      
        34
                rowmark := arrayCreate(numberofVars, 0);
      
        34
                (arr,arrT) := adjacencyMatrixDispatchEnhanced(vars, eqns, arr,arrT, 0, numberOfEqs, intLt(0, numberOfEqs),rowmark,globalKnownVars,trytosolve,shared);
      
              then
      
                (arr,arrT);
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"BackendDAEUtil.getAdjacencyMatrixEnhanced failed"});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end getAdjacencyMatrixEnhanced;
      
        protected function adjacencyMatrixDispatchEnhanced
      
        "@author: Frenkel TUD 2012-05
      
          Calculates the adjacency matrix and the transposed
      
          adjacency matrix."
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.EquationArray eqArr;
      
          input BackendDAE.AdjacencyMatrixEnhanced inAdjacencyArray;
      
          input BackendDAE.AdjacencyMatrixTEnhanced inAdjacencyArrayT;
      
          input Integer index;
      
          input Integer numberOfEqs;
      
          input Boolean stop;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Boolean trytosolve;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.AdjacencyMatrixEnhanced outAdjacencyArray;
      
          output BackendDAE.AdjacencyMatrixTEnhanced outAdjacencyArrayT;
      
        algorithm
      
          (outAdjacencyArray,outAdjacencyArrayT) :=
      
            match stop
      
            local
      
              BackendDAE.AdjacencyMatrixElementEnhanced row;
      
              BackendDAE.Equation e;
      
              BackendDAE.AdjacencyMatrixEnhanced iArr;
      
              BackendDAE.AdjacencyMatrixTEnhanced iArrT;
      
              Integer i1;
      
            // index = numberOfEqs (we reach the end)
      
            case false
      
            then (inAdjacencyArray, inAdjacencyArrayT);
      
            // index < numberOfEqs
      
            case true
      
              algorithm
      
        2226
                i1 := index+1;
      
                // get the equation
      
        2226
                e := BackendEquation.get(eqArr, i1);
      
                // compute the row
      
        2226
                (row,_,_) := adjacencyRowEnhanced(vars, e, i1, rowmark, globalKnownVars, trytosolve,shared);
      
                // put it in the arrays
      
        2226
                iArr := arrayUpdate(inAdjacencyArray, i1, row);
      
        2226
                iArrT := fillincAdjacencyMatrixTEnhanced(row,{i1},inAdjacencyArrayT);
      
        2226
                (iArr,iArrT) := adjacencyMatrixDispatchEnhanced(vars, eqArr, iArr, iArrT, i1, numberOfEqs, intLt(i1, numberOfEqs), rowmark, globalKnownVars, trytosolve, shared);
      
              then
      
                (iArr,iArrT);
      
          end match;
      
        end adjacencyMatrixDispatchEnhanced;
      
        protected function fillincAdjacencyMatrixTEnhanced
      
        "@author: Frenkel TUD 2011-04
      
          helper for adjacencyMatrixDispatchEnhanced.
      
          Inserts the rows in the transposed adjacency matrix."
      
          input BackendDAE.AdjacencyMatrixElementEnhanced eqns;
      
          input list<Integer> eqnsindxs;
      
          input BackendDAE.AdjacencyMatrixTEnhanced inAdjacencyArrayT;
      
          output BackendDAE.AdjacencyMatrixTEnhanced outAdjacencyArrayT;
      
        algorithm
      
          outAdjacencyArrayT := matchcontinue eqns
      
            local
      
              BackendDAE.AdjacencyMatrixElementEnhanced row,rest,newrow;
      
              Integer v,vabs;
      
              BackendDAE.AdjacencyMatrixTEnhanced mT;
      
              BackendDAE.Solvability solva;
      
              BackendDAE.Constraints cons;
      
              list<Integer> eqnsindxs1;
      
            case {} then inAdjacencyArrayT;
      
            case (v,solva,cons)::rest
      
              guard
      
                intLt(0, v)
      
              algorithm
      
        119655
                row := inAdjacencyArrayT[v];
      
        119655
                newrow := List.map2(eqnsindxs,Util.make3Tuple,solva,cons);
      
        119655
                row := listAppend(newrow,row);
      
                // put it in the array
      
        119655
                mT := arrayUpdate(inAdjacencyArrayT, v, row);
      
        119655
              then
      
                fillincAdjacencyMatrixTEnhanced(rest, eqnsindxs, mT);
      
            case (v,solva,cons)::rest
      
              algorithm
      
        41404
                vabs := intAbs(v);
      
        41404
                row := inAdjacencyArrayT[vabs];
      
        41404
                eqnsindxs1 := List.map(eqnsindxs,intNeg);
      
        41404
                newrow := List.map2(eqnsindxs1,Util.make3Tuple,solva,cons);
      
                // put it in the array
      
        41404
                row := listAppend(newrow,row);
      
        41404
                mT := arrayUpdate(inAdjacencyArrayT, vabs, row);
      
        41404
              then
      
                fillincAdjacencyMatrixTEnhanced(rest, eqnsindxs, mT);
      
            case _
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"BackendDAEUtil.fillincAdjacencyMatrixTEnhanced failed"});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end fillincAdjacencyMatrixTEnhanced;
      
        public function adjacencyRowEnhanced
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyMatrixDispatchEnhanced. Calculates the adjacency row
      
          in the matrix for one equation."
      
          input BackendDAE.Variables inVariables;
      
          input BackendDAE.Equation inEquation;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Boolean trytosolve;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
      
          output Integer size;
      
          output list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTuple={};
      
        protected
      
          Boolean isInitial;
      
        algorithm
      
        49769
          isInitial := isInitializationDAE(shared);
      
          (outRow,size) := matchcontinue (inVariables, inEquation)
      
            local
      
              list<Integer> lst,ds, lstall, varsSolvedInWhenEqns;
      
              BackendDAE.Variables vars;
      
              DAE.Exp e1,e2,e,expCref;
      
              list<DAE.Exp> expl;
      
              DAE.ComponentRef cr;
      
              BackendDAE.WhenEquation elsewe;
      
              String eqnstr;
      
              DAE.Algorithm alg;
      
              BackendDAE.AdjacencyMatrixElementEnhanced row, row1;
      
              list<list<BackendDAE.Equation>> eqnslst;
      
              list<BackendDAE.Equation> eqns,eqnselse;
      
              list<DAE.ComponentRef> algoutCrefs;
      
              DAE.Expand crefExpand;
      
              DAE.ElementSource source;
      
            // EQUATION
      
            case (vars, BackendDAE.EQUATION(exp = e1,scalar = e2))
      
              algorithm
      
        49340
                lst := adjacencyRowExpEnhanced(e1, vars, mark, rowmark, isInitial, {});
      
        49340
                lst := adjacencyRowExpEnhanced(e2, vars, mark, rowmark, isInitial, lst);
      
        49340
                row := adjacencyRowEnhanced1(lst,e1,e2,vars,globalKnownVars,mark,rowmark,{},trytosolve,1,shared);
      
              then
      
                (row,1);
      
            // COMPLEX_EQUATION
      
            case (vars, BackendDAE.COMPLEX_EQUATION(size=size,left=e1,right=e2))
      
              algorithm
      
        357
                lst := adjacencyRowExpEnhanced(e1, vars, mark, rowmark, isInitial, {});
      
        357
                lst := adjacencyRowExpEnhanced(e2, vars, mark, rowmark, isInitial, lst);
      
        357
                row := adjacencyRowEnhanced1(lst,e1,e2,vars,globalKnownVars,mark,rowmark,{},trytosolve,size,shared);
      
        357
              then
      
                (row,size);
      
            // ARRAY_EQUATION
      
            case (vars, BackendDAE.ARRAY_EQUATION(dimSize=ds,left=e1,right=e2))
      
              algorithm
      
        23
                lst := adjacencyRowExpEnhanced(e1, vars, mark, rowmark, isInitial, {});
      
        23
                lst := adjacencyRowExpEnhanced(e2, vars, mark, rowmark, isInitial, lst);
      
        23
                size := List.fold(ds,intMul,1);
      
        23
                row := adjacencyRowEnhanced1(lst,e1,e2,vars,globalKnownVars,mark,rowmark,{},trytosolve,size,shared);
      
        23
              then
      
                (row,size);
      
            // SOLVED_EQUATION
      
            case (vars, BackendDAE.SOLVED_EQUATION(componentRef = cr,exp = e))
      
              algorithm
      
        ✗
                expCref := Expression.crefExp(cr);
      
        ✗
                lst := adjacencyRowExpEnhanced(expCref, vars, mark, rowmark, isInitial, {});
      
        ✗
                lst := adjacencyRowExpEnhanced(e, vars, mark, rowmark, isInitial, lst);
      
        ✗
                row := adjacencyRowEnhanced1(lst,expCref,e,vars,globalKnownVars,mark,rowmark,{},trytosolve,1,shared);
      
              then
      
                (row,1);
      
            // RESIDUAL_EQUATION
      
            case (vars, BackendDAE.RESIDUAL_EQUATION(exp = e))
      
              algorithm
      
        ✗
                lst := adjacencyRowExpEnhanced(e, vars, mark, rowmark, isInitial, {});
      
        ✗
                row := adjacencyRowEnhanced1(lst,e,DAE.RCONST(0.0),vars,globalKnownVars,mark,rowmark,{},trytosolve,1,shared);
      
              then
      
                (row,1);
      
            // WHEN_EQUATION
      
            case (vars, BackendDAE.WHEN_EQUATION(size=size,whenEquation = elsewe))
      
              algorithm
      
        7
                (row,varsSolvedInWhenEqns) := adjacencyRowWhenEnhanced(elsewe, mark, rowmark, vars, globalKnownVars, {}, {},shared);
      
        7
                varsSolvedInWhenEqnsTuple := {(mark,varsSolvedInWhenEqns)};
      
        7
              then
      
                (row,size);
      
            // ALGORITHM For now assume that algorithm will be solvable for
      
            // output variables. Mark this as solved and input variables as unsolvable:
      
            case (vars, BackendDAE.ALGORITHM(size=size,alg=alg,source=source,expand=crefExpand))
      
              algorithm
      
                // get outputs
      
        42
                algoutCrefs := CheckModel.checkAndGetAlgorithmOutputs(alg, source, crefExpand);
      
                // mark outputs as solved
      
        42
                row := adjacencyRowAlgorithmOutputs(algoutCrefs,vars,mark,rowmark,{});
      
                // get inputs
      
        42
                expl := Algorithm.getAllExps(alg);
      
                // mark inputs as unsolvable
      
        42
                (_,(_,_,_,row)) := Expression.traverseExpList(expl, adjacencyRowAlgorithmInputs, (vars,mark,rowmark,row));
      
        42
              then
      
                (row,size);
      
            /*
      
              special case: initial()
      
              if initial() then ... else ... end if;
      
              only then branch needs to be checked for initialization and else branch otherwise
      
            */
      
            case(_, BackendDAE.IF_EQUATION(conditions={DAE.CALL(path=Absyn.IDENT("initial"))},eqnstrue={eqns}, eqnsfalse=eqnselse))
      
              algorithm
      
        ✗
                if isInitializationDAE(shared) then
      
        ✗
                  (row,size) := adjacencyRowEnhancedEqnLst(eqns,inVariables,mark,rowmark,globalKnownVars,trytosolve,shared);
      
                else
      
        ✗
                  (row,size) := adjacencyRowEnhancedEqnLst(eqnselse,inVariables,mark,rowmark,globalKnownVars,trytosolve,shared);
      
                end if;
      
        ✗
              then
      
                (row,size);
      
            /*
      
              special case: NEGATED initial()
      
              if not initial() then ... else ... end if;
      
              only else branch needs to be checked for initialization and then branch otherwise
      
            */
      
            case(_, BackendDAE.IF_EQUATION(conditions={DAE.LUNARY(DAE.NOT(), DAE.CALL(path=Absyn.IDENT("initial")))},eqnstrue={eqns}, eqnsfalse=eqnselse))
      
              algorithm
      
        ✗
                if isInitializationDAE(shared) then
      
        ✗
                  (row,size) := adjacencyRowEnhancedEqnLst(eqnselse,inVariables,mark,rowmark,globalKnownVars,trytosolve,shared);
      
                else
      
        ✗
                  (row,size) := adjacencyRowEnhancedEqnLst(eqns,inVariables,mark,rowmark,globalKnownVars,trytosolve,shared);
      
                end if;
      
        ✗
              then
      
                (row,size);
      
            // if Equation
      
            // TODO : how to handle this?
      
            // Proposal:
      
            // 1. mark all vars in conditions as unsolvable
      
            // 2. vars occur in all branches: check how they are occur
      
            // 3. vars occur not in all branches: mark as unsolvable
      
            case(vars, BackendDAE.IF_EQUATION(conditions=expl,eqnstrue=eqnslst,eqnsfalse=eqnselse))
      
              algorithm
      
                //print("Warning: BackendDAEUtil.adjacencyRowEnhanced does not handle if-equations propper!\n");
      
                // mark all negative because the when condition cannot used to solve a variable
      
        ✗
                lst := List.fold4(expl, adjacencyRowExpEnhanced, vars, mark, rowmark, isInitial, {});
      
        ✗
                List.fold1(lst,markNegativ,rowmark,mark);
      
        ✗
                row1 := adjacencyRowEnhanced1(lst,DAE.RCONST(0.0),DAE.RCONST(0.0),vars,globalKnownVars,mark,rowmark,{},trytosolve,1,shared);
      
        ✗
                (row, size) := adjacencyRowEnhancedEqnLst(eqnselse, vars, mark, rowmark, globalKnownVars, trytosolve,shared);
      
        ✗
                lst := List.map(row,Util.tuple31);
      
        ✗
                for eq in eqnslst loop
      
        ✗
                  (lst, row, _) := adjacencyRowEnhancedEqnLstIfBranches(eq, vars, mark, rowmark, globalKnownVars, trytosolve, shared, (lst, row, size));
      
                end for;
      
        ✗
                lstall := List.map(row, Util.tuple31);
      
        ✗
                (_, lst, _) := List.intersection1OnTrue(lstall, lst, intEq);
      
        ✗
                List.fold1(lst, markNegativ, rowmark, mark);
      
        ✗
                row := listAppend(row1,row);
      
        ✗
              then
      
                (row,size);
      
            else
      
              algorithm
      
        ✗
                eqnstr := BackendDump.equationString(inEquation);
      
        ✗
                eqnstr := stringAppendList({"BackendDAE.adjacencyRowEnhanced failed for eqn:\n",eqnstr,"\n"});
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{eqnstr});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end adjacencyRowEnhanced;
      
        protected function adjacencyRowEnhancedEqnLstIfBranches
      
          input list<BackendDAE.Equation> iEqns;
      
          input BackendDAE.Variables inVariables;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Boolean trytosolve;
      
          input BackendDAE.Shared shared;
      
          input tuple<list<Integer>,BackendDAE.AdjacencyMatrixElementEnhanced,Integer> intpl;
      
          output tuple<list<Integer>,BackendDAE.AdjacencyMatrixElementEnhanced,Integer> outtpl;
      
        protected
      
          BackendDAE.AdjacencyMatrixElementEnhanced row, iRow;
      
          list<Integer> lst, inLstAllBranch;
      
          Integer size, iSize;
      
        algorithm
      
        ✗
          (inLstAllBranch,iRow,iSize) := intpl;
      
        ✗
          for eqn in iEqns loop
      
        ✗
            (row,size,_) := adjacencyRowEnhanced(inVariables, eqn, mark, rowmark, globalKnownVars, trytosolve,shared);
      
        ✗
            lst := List.map(row,Util.tuple31);
      
        ✗
            inLstAllBranch := List.intersectionOnTrue(lst, inLstAllBranch,intEq);
      
        ✗
            iSize := iSize + size;
      
        ✗
            iRow := listAppend(row,iRow);
      
          end for;
      
        ✗
          outtpl := (inLstAllBranch,iRow,iSize);
      
        end adjacencyRowEnhancedEqnLstIfBranches;
      
        protected function adjacencyRowEnhancedEqnLst
      
          input list<BackendDAE.Equation> iEqns;
      
          input BackendDAE.Variables inVariables;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Boolean trytosolve;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow = {};
      
          output Integer oSize = 0;
      
        protected
      
          BackendDAE.AdjacencyMatrixElementEnhanced row;
      
          Integer size;
      
        algorithm
      
        ✗
          for eqn in iEqns loop
      
        ✗
            (row,size,_) := adjacencyRowEnhanced(inVariables,eqn,mark,rowmark,globalKnownVars,trytosolve,shared);
      
        ✗
            outRow := listAppend(row,outRow);
      
        ✗
            oSize := oSize + size;
      
          end for;
      
        end adjacencyRowEnhancedEqnLst;
      
        protected function adjacencyRowAlgorithmOutputs
      
        "author: Frenkel TUD 10-2012
      
          Helper function to adjacencyRowEnhanced. Mark all algorithm outputs
      
          as solved."
      
          input list<DAE.ComponentRef> algOutputs;
      
          input BackendDAE.Variables inVariables;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.AdjacencyMatrixElementEnhanced iRow;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
      
        algorithm
      
          outRow := match algOutputs
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.ComponentRef> rest;
      
              list<Integer> vindx;
      
              BackendDAE.AdjacencyMatrixElementEnhanced row;
      
            case {} then iRow;
      
            case cr::rest
      
              algorithm
      
        96
                (_,vindx) := BackendVariable.getVar(cr,inVariables);
      
        96
                row := adjacencyRowAlgorithmOutputs1(vindx,mark,rowmark,iRow);
      
        96
              then
      
                adjacencyRowAlgorithmOutputs(rest,inVariables,mark,rowmark,row);
      
          end match;
      
        end adjacencyRowAlgorithmOutputs;
      
        protected function adjacencyRowAlgorithmOutputs1
      
        "author: Frenkel TUD 10-2012
      
          Helper function to adjacencyRowEnhanced. Mark all algorithm outputs
      
          as solved."
      
          input list<Integer> vindx;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.AdjacencyMatrixElementEnhanced iRow;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
      
        algorithm
      
          outRow := match vindx
      
            local
      
              Integer i;
      
              list<Integer> rest;
      
            case {} then iRow;
      
            case i::rest
      
              algorithm
      
        96
                arrayUpdate(rowmark,i,mark);
      
        192
              then
      
                adjacencyRowAlgorithmOutputs1(rest,mark,rowmark,(i,BackendDAE.SOLVABILITY_SOLVED(),{})::iRow);
      
          end match;
      
        end adjacencyRowAlgorithmOutputs1;
      
        protected function adjacencyRowAlgorithmInputs
      
        "author: Frenkel TUD 10-2012
      
          Helper function to adjacencyRowEnhanced. Mark all algorithm inputs
      
          as unsolvable."
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,Integer,array<Integer>,BackendDAE.AdjacencyMatrixElementEnhanced> iTpl;
      
          output DAE.Exp outExp;
      
          output tuple<BackendDAE.Variables,Integer,array<Integer>,BackendDAE.AdjacencyMatrixElementEnhanced> oTpl;
      
        algorithm
      
          (outExp,oTpl) := matchcontinue (inExp,iTpl)
      
            local
      
              DAE.Exp e;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              Integer mark;
      
              array<Integer>rowmark;
      
              BackendDAE.AdjacencyMatrixElementEnhanced row;
      
              list<Integer> vindx;
      
            case (e as DAE.CREF(componentRef=cr),(vars,mark,rowmark,row))
      
              algorithm
      
        1510
                (_,vindx) := BackendVariable.getVar(cr,vars);
      
        548
                row := adjacencyRowAlgorithmInputs1(vindx,mark,rowmark,row);
      
        548
              then (e,(vars,mark,rowmark,row));
      
            else (inExp,iTpl);
      
          end matchcontinue;
      
        end adjacencyRowAlgorithmInputs;
      
        protected function adjacencyRowAlgorithmInputs1
      
        "author: Frenkel TUD 10-2012
      
          Helper function to adjacencyRowEnhanced. Mark all algorithm inputs
      
          as unsolvable."
      
          input list<Integer> vindx;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.AdjacencyMatrixElementEnhanced iRow;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
      
        algorithm
      
          outRow := match vindx
      
            local
      
              Integer i;
      
              list<Integer> rest;
      
            case {} then iRow;
      
            case i::rest
      
              guard
      
                // not already handled
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
        104
                arrayUpdate(rowmark,i,-mark);
      
        208
              then
      
                adjacencyRowAlgorithmInputs1(rest,mark,rowmark,(i,BackendDAE.SOLVABILITY_UNSOLVABLE(),{})::iRow);
      
            case _::rest
      
        609
              then
      
                adjacencyRowAlgorithmInputs1(rest,mark,rowmark,iRow);
      
          end match;
      
        end adjacencyRowAlgorithmInputs1;
      
        protected function adjacencyRowWhenEnhanced
      
        "author: Frenkel TUD
      
          Helper function to adjacencyMatrixDispatchEnhanced. Calculates the adjacency row
      
          in the matrix for one equation."
      
          input BackendDAE.WhenEquation inEquation;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.Variables globalKnownVars;
      
          input list<Integer> iLst;
      
          input BackendDAE.AdjacencyMatrixElementEnhanced iRow;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow = iRow;
      
          output list<Integer> varsSolvedInWhenEqns={};
      
        protected
      
          DAE.Exp condition;
      
          list<BackendDAE.WhenOperator> whenStmtLst;
      
          Option<BackendDAE.WhenEquation> oelsepart;
      
          list<Integer> lst;
      
          BackendDAE.WhenEquation elsepart;
      
          Boolean isInitial;
      
        algorithm
      
        7
          isInitial := isInitializationDAE(shared);
      
        7
          BackendDAE.WHEN_STMTS(condition = condition, whenStmtLst = whenStmtLst, elsewhenPart = oelsepart) := inEquation;
      
        7
          lst := adjacencyRowExpEnhanced(condition, vars, mark, rowmark, isInitial, iLst);
      
          2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 7 times.

        14
          for rs in whenStmtLst loop
      
            () := match rs
      
              local
      
                Integer varIndx;
      
                list<Integer> varIdcs;
      
                DAE.ComponentRef left;
      
                list<DAE.ComponentRef> crefs;
      
                DAE.Exp right, leftexp;
      
              case BackendDAE.ASSIGN(left = leftexp as DAE.CREF(componentRef = left), right=right)
      
                algorithm
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.

        7
                (_,{varIndx}) := BackendVariable.getVar(left, vars);
      
                varsSolvedInWhenEqns := varIndx :: varsSolvedInWhenEqns;
      
        7
                lst := adjacencyRowExpEnhanced(right, vars, mark, rowmark, isInitial, lst);
      
                // mark all negative because the when condition cannot used to solve a variable
      
        7
                List.fold1(lst,markNegativ,rowmark,mark);
      
                //leftexp = Expression.crefExp(left);
      
        7
                lst := adjacencyRowExpEnhanced(leftexp, vars, mark, rowmark, isInitial, lst);
      
        7
                outRow := adjacencyRowEnhanced1(lst,leftexp,right,vars,globalKnownVars,mark,rowmark,outRow,false,1,shared);
      
              then ();
      
              case BackendDAE.ASSIGN(leftexp, right) algorithm
      
        ✗
                crefs := Expression.getAllCrefs(leftexp);
      
        ✗
                (_,varIdcs) := BackendVariable.getVarLst(crefs, vars);
      
        ✗
                varsSolvedInWhenEqns := listAppend(varIdcs, varsSolvedInWhenEqns);
      
        ✗
                lst := adjacencyRowExpEnhanced(right, vars, mark, rowmark, isInitial, lst);
      
                // mark all negative because the when condition cannot used to solve a variable
      
        ✗
                List.fold1(lst,markNegativ,rowmark,mark);
      
        ✗
                lst := adjacencyRowExpEnhanced(leftexp, vars, mark, rowmark, isInitial, lst);
      
        ✗
                outRow := adjacencyRowEnhanced1(lst,leftexp,right,vars,globalKnownVars,mark,rowmark,outRow,false,1,shared);
      
              then ();
      
              else ();
      
            end match;
      
          end for;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.

        7
          if isSome(oelsepart) then
      
        ✗
            SOME(elsepart) := oelsepart;
      
        ✗
            outRow := adjacencyRowWhenEnhanced(elsepart, mark, rowmark, vars, globalKnownVars, lst, outRow, shared);
      
          end if;
      
        end adjacencyRowWhenEnhanced;
      
        protected function markNegativ
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyRowEnhanced. Update the array
      
          with a negative entry in indx."
      
          input Integer indx;
      
          input array<Integer> rowmark;
      
          input Integer mark;
      
          output Integer oMark;
      
        algorithm
      
        15
          arrayUpdate(rowmark,indx,-mark);
      
          oMark := mark;
      
        end markNegativ;
      
        protected function adjacencyRowEnhanced1
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyRowEnhanced. Calculates the
      
          solvability of the variables."
      
          input list<Integer> lst;
      
          input DAE.Exp e1;
      
          input DAE.Exp e2;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.Variables globalKnownVars;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BackendDAE.AdjacencyMatrixElementEnhanced inRow;
      
          input Boolean trytosolve;
      
          input Integer size;
      
          input BackendDAE.Shared shared;
      
          output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
      
        algorithm
      
          outRow := matchcontinue(lst, e1, e2)
      
            local
      
              Integer r,rabs;
      
              list<Integer> rest;
      
              DAE.Exp de,e, e_derAlias;
      
              DAE.ComponentRef cr,cr1,crarr;
      
              BackendDAE.Solvability solvab;
      
              list<DAE.ComponentRef> crlst;
      
              Absyn.Path path,path1;
      
              list<DAE.Exp> explst,crexplst;
      
              Boolean solved,derived;
      
              BackendDAE.Constraints cons;
      
            case({}, _, _) then inRow;
      
        /*    case(r::rest,_,_,_,_,_,_,_)
      
              algorithm
      
                // if r negativ then unsolvable
      
                true = intLt(r,0);
      
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_UNSOLVABLE())::inRow,trytosolve);
      
        */
      
            case(r::rest, DAE.CALL(path= Absyn.IDENT("der"),expLst={DAE.CREF(componentRef = cr)}), _)
      
              guard
      
                intGt(r,0)
      
              algorithm
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 426 times.

        426
                false := intEq(rowmark[r],-mark);
      
                // solved?
      
          2/2✓ Branch 1 taken 261 times.
✓ Branch 2 taken 165 times.

        426
                BackendDAE.VAR(varName=cr1,varKind=BackendDAE.STATE()) := BackendVariable.getVarAt(vars, r);
      
          2/2✓ Branch 1 taken 17 times.
✓ Branch 2 taken 148 times.

        165
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 148 times.

        148
                false := Expression.expHasDerCref(e2,cr);
      
        296
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.CALL(path= Absyn.IDENT("der"),expLst={DAE.CREF(componentRef = cr)}))
      
              algorithm
      
        96
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 96 times.

        96
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
          2/2✓ Branch 1 taken 48 times.
✓ Branch 2 taken 48 times.

        96
                BackendDAE.VAR(varName=cr1,varKind=BackendDAE.STATE()) := BackendVariable.getVarAt(vars, rabs);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.

        48
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 48 times.

        48
                false := Expression.expHasDerCref(e1,cr);
      
        96
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.CREF(componentRef=cr), _)
      
              algorithm
      
        122522
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          2/2✓ Branch 1 taken 6474 times.
✓ Branch 2 taken 116048 times.

        122522
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        116048
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 79860 times.
✓ Branch 2 taken 36188 times.

        116048
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          2/2✓ Branch 1 taken 20 times.
✓ Branch 2 taken 36168 times.

        36188
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        72336
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.CREF(componentRef=cr), _)
      
              algorithm
      
        86354
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          2/2✓ Branch 1 taken 6474 times.
✓ Branch 2 taken 79880 times.

        86354
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        79880
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        79880
                crarr := ComponentReferenceBasics.crefStripLastSubs(cr1);
      
          2/2✓ Branch 1 taken 79860 times.
✓ Branch 2 taken 20 times.

        79880
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, crarr);
      
          1/2✓ Branch 1 taken 20 times.
✗ Branch 2 not taken.

        20
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.LUNARY(operator=DAE.NOT(_),exp=DAE.CREF(componentRef=cr)), _)
      
              algorithm
      
        ✗
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.UNARY(operator=DAE.UMINUS(_),exp=DAE.CREF(componentRef=cr)), _)
      
              algorithm
      
        7086
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 7084 times.

        7086
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        7084
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 4977 times.
✓ Branch 2 taken 2107 times.

        7084
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2107 times.

        2107
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        4214
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.UNARY(operator=DAE.UMINUS_ARR(_),exp=DAE.CREF(componentRef=cr)), _)
      
              algorithm
      
        ✗
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                crarr := ComponentReferenceBasics.crefStripLastSubs(cr1);
      
        ✗
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, crarr);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.CREF(componentRef=cr))
      
              algorithm
      
        5324
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 5324 times.

        5324
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        5324
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 3085 times.
✓ Branch 2 taken 2239 times.

        5324
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2239 times.

        2239
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        4478
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.CREF(componentRef=cr))
      
              algorithm
      
        3085
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3085 times.

        3085
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        3085
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        3085
                crarr := ComponentReferenceBasics.crefStripLastSubs(cr1);
      
          1/2✓ Branch 1 taken 3085 times.
✗ Branch 2 not taken.

        3085
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, crarr);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.LUNARY(operator=DAE.NOT(_),exp=DAE.CREF(componentRef=cr)))
      
              algorithm
      
        ✗
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.UNARY(operator=DAE.UMINUS(_),exp=DAE.CREF(componentRef=cr)))
      
              algorithm
      
        69
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 69 times.

        69
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        69
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 18 times.
✓ Branch 2 taken 51 times.

        69
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, cr1);
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 49 times.

        51
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        98
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.UNARY(operator=DAE.UMINUS_ARR(_),exp=DAE.CREF(componentRef=cr)))
      
              algorithm
      
        ✗
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                crarr := ComponentReferenceBasics.crefStripLastSubs(cr1);
      
        ✗
                true := ComponentReferenceBasics.crefEqualNoStringCompare(cr, crarr);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.CREF(componentRef=cr), _)
      
              algorithm
      
        85086
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          2/2✓ Branch 1 taken 6474 times.
✓ Branch 2 taken 78612 times.

        85086
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        78612
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 77698 times.
✓ Branch 2 taken 914 times.

        78612
                true := ComponentReferenceBasics.crefPrefixOf(cr, cr1);
      
          2/2✓ Branch 1 taken 20 times.
✓ Branch 2 taken 894 times.

        914
                false := Expression.expHasCrefNoPreorDer(e2,cr);
      
        1788
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.CREF(componentRef=cr))
      
              algorithm
      
        3085
                rabs := intAbs(r);
      
                // if not negatet rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3085 times.

        3085
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        3085
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          1/2✓ Branch 1 taken 3085 times.
✗ Branch 2 not taken.

        3085
                true := ComponentReferenceBasics.crefPrefixOf(cr, cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.CALL(path=path,expLst=explst,attr=DAE.CALL_ATTR(ty= DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(path1)))), _)
      
              algorithm
      
        ✗
                true := AbsynUtil.pathEqual(path,path1);
      
        ✗
                rabs := intAbs(r);
      
                // if not negated rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                true := expCrefLstHasCref(explst,cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e2,cr1);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.CALL(path=path,expLst=explst,attr=DAE.CALL_ATTR(ty= DAE.T_COMPLEX(complexClassType=ClassInf.RECORD(path1)))))
      
              algorithm
      
          1/2✓ Branch 1 taken 1356 times.
✗ Branch 2 not taken.

        1356
                true := AbsynUtil.pathEqual(path,path1);
      
        ✗
                rabs := intAbs(r);
      
                // if not negated rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                true := expCrefLstHasCref(explst,cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr1);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.RECORD(exps=explst), _)
      
              algorithm
      
        1238
                rabs := intAbs(r);
      
                // if not negated rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1238 times.

        1238
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        1238
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 193 times.
✓ Branch 2 taken 1045 times.

        1238
                true := expCrefLstHasCref(explst,cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1045 times.

        1045
                false := Expression.expHasCrefNoPreorDer(e2,cr1);
      
        2090
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, DAE.RECORD(exps=explst))
      
              algorithm
      
        ✗
                rabs := intAbs(r);
      
                // if not negated rowmark then
      
        ✗
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        ✗
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        ✗
                true := expCrefLstHasCref(explst,cr1);
      
        ✗
                false := Expression.expHasCrefNoPreorDer(e1,cr1);
      
        ✗
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, DAE.TUPLE(PR=explst), DAE.CALL())
      
              algorithm
      
        1626
                rabs := intAbs(r);
      
                // if not negated rowmark then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1626 times.

        1626
                false := intEq(rowmark[rabs],-mark);
      
                // solved?
      
        1626
                BackendDAE.VAR(varName=cr1) := BackendVariable.getVarAt(vars, rabs);
      
        1626
                explst := List.flatten(List.map1(explst, Expression.generateCrefsExpLstFromExp, NONE()));
      
        1626
                crlst := List.map(explst, Expression.expCref);
      
        1626
                crlst := List.flatten(List.map1(crlst, ComponentReference.expandCref, true));
      
        1626
                crexplst := List.map(crlst, Expression.crefExp);
      
          2/2✓ Branch 1 taken 525 times.
✓ Branch 2 taken 1101 times.

        1626
                true := expCrefLstHasCref(crexplst,cr1);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1101 times.

        1101
                false := Expression.expHasCrefNoPreorDer(e2,cr1);
      
        2202
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_SOLVED(),{})::inRow,trytosolve,size,shared);
      
            case(r::rest, _, _)
      
              // case: state derivative
      
              algorithm
      
                // ticket #6806, only allow inverting of function if the sizes match
      
          2/2✓ Branch 0 taken 852 times.
✓ Branch 1 taken 116275 times.

        117127
                1 := size;
      
                // if not negated rowmark then linear or nonlinear
      
          2/2✓ Branch 0 taken 27782 times.
✓ Branch 1 taken 88493 times.

        116275
                true := intGt(r,0);
      
          2/2✓ Branch 1 taken 6780 times.
✓ Branch 2 taken 81713 times.

        88493
                false := intEq(rowmark[r],-mark);
      
                // de/dvar
      
          2/2✓ Branch 1 taken 80122 times.
✓ Branch 2 taken 1591 times.

        81713
                BackendDAE.VAR(varName=cr,varKind=BackendDAE.STATE()) := BackendVariable.getVarAt(vars, r);
      
        1591
                cr1 := ComponentReference.crefPrefixDer(cr);
      
        1591
                e := Expression.crefExp(cr);
      
        1591
                (e,_) := Expression.replaceExp(Expression.expSub(e1,e2), DAE.CALL(Absyn.IDENT("der"),{e},DAE.callAttrBuiltinReal), Expression.crefExp(cr1));
      
        1591
                e_derAlias := Expression.traverseExpDummy(e, replaceDerCall);
      
        1591
                (de,solved,derived,cons) := tryToSolveOrDerive(e_derAlias, cr1, vars, SOME(shared.functionTree),trytosolve);
      
          1/2✓ Branch 0 taken 1391 times.
✗ Branch 1 not taken.

        1391
                if not solved then
      
        1391
                  (de,_) := ExpressionSimplify.simplify(de);
      
        1391
                  (_,crlst) := Expression.traverseExpBottomUp(de, Expression.traversingComponentRefFinder, {});
      
        1391
                  solvab := adjacencyRowEnhanced2(cr1,de,crlst,vars,globalKnownVars);
      
                else
      
        ✗
                  if derived then
      
        ✗
                    (de,_) := ExpressionSimplify.simplify(de);
      
        ✗
                    (_,crlst) := Expression.traverseExpBottomUp(de, Expression.traversingComponentRefFinder, {});
      
        ✗
                    solvab := adjacencyRowEnhanced2(cr1,de,crlst,vars,globalKnownVars);
      
        ✗
                    solvab := transformSolvabilityForCasualTearingSet(solvab);
      
                  else
      
                    solvab := BackendDAE.SOLVABILITY_SOLVABLE();
      
                  end if;
      
                end if;
      
        2782
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,solvab,cons)::inRow,trytosolve,size,shared);
      
            case(r::rest, _, _)
      
              algorithm
      
                // ticket #6806, only allow inverting of function if the sizes match
      
          2/2✓ Branch 0 taken 852 times.
✓ Branch 1 taken 114884 times.

        115736
                1 := size;
      
        114884
                rabs := intAbs(r);
      
                // if not negated rowmark then linear or nonlinear
      
          2/2✓ Branch 1 taken 7271 times.
✓ Branch 2 taken 107613 times.

        114884
                false := intEq(rowmark[rabs],-mark);
      
                // de/dvar
      
        107613
                BackendDAE.VAR(varName=cr) := BackendVariable.getVarAt(vars, rabs);
      
          2/2✓ Branch 1 taken 523 times.
✓ Branch 2 taken 107090 times.

        107613
                if CommonSubExpression.isCSECref(cr) then
      
                  solvab := BackendDAE.SOLVABILITY_UNSOLVABLE();
      
        523
                  cons := {};
      
                else
      
        107090
                  e := Expression.expSub(e1,e2);
      
        107089
                  e_derAlias := Expression.traverseExpDummy(e, replaceDerCall);
      
        107089
                  (de,solved,derived,cons) := tryToSolveOrDerive(e_derAlias, cr, vars, SOME(shared.functionTree),trytosolve);
      
          2/2✓ Branch 0 taken 95150 times.
✓ Branch 1 taken 3023 times.

        98173
                  if not solved then
      
        95150
                    (de,_) := ExpressionSimplify.simplify(de);
      
        95150
                    (_,crlst) := Expression.traverseExpTopDown(de, Expression.traversingComponentRefFinderNoPreDer, {});
      
        95150
                    solvab := adjacencyRowEnhanced2(cr,de,crlst,vars,globalKnownVars);
      
                  else
      
          1/2✓ Branch 0 taken 3023 times.
✗ Branch 1 not taken.

        3023
                    if derived then
      
        3023
                      (de,_) := ExpressionSimplify.simplify(de);
      
        3023
                      (_,crlst) := Expression.traverseExpTopDown(de, Expression.traversingComponentRefFinderNoPreDer, {});
      
        3023
                      solvab := adjacencyRowEnhanced2(cr,de,crlst,vars,globalKnownVars);
      
        3023
                      solvab := transformSolvabilityForCasualTearingSet(solvab);
      
                    else
      
                      solvab := BackendDAE.SOLVABILITY_SOLVABLE();
      
                    end if;
      
                  end if;
      
                end if;
      
        197392
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,solvab,cons)::inRow,trytosolve,size,shared);
      
            case(r::rest, _, _)
      
        34080
              then
      
                adjacencyRowEnhanced1(rest,e1,e2,vars,globalKnownVars,mark,rowmark,(r,BackendDAE.SOLVABILITY_UNSOLVABLE(),{})::inRow,trytosolve,size,shared);
      
          end matchcontinue;
      
        end adjacencyRowEnhanced1;
      
        protected function replaceDerCall "
      
          replaces der-calls in expression with alias-variable"
      
          input DAE.Exp inExp;
      
          output DAE.Exp outExp;
      
        algorithm
      
          outExp := matchcontinue inExp
      
            local
      
              DAE.ComponentRef cr;
      
              DAE.Type ty;
      
              BackendDAE.Var v;
      
            case DAE.CALL(path=Absyn.IDENT(name="der"), expLst={DAE.CREF(componentRef=cr, ty=ty)})
      
              algorithm
      
        5247
                v := BackendVariable.createAliasDerVar(cr);
      
        5247
                cr := BackendVariable.varCref(v);
      
        5247
                outExp := DAE.CREF(cr,ty);
      
              then (outExp);
      
            case DAE.CALL(path=Absyn.IDENT(name="der"))
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {getInstanceName() + " failed for: " + ExpressionBasics.printExpStr(inExp) + "\n"});
      
        ✗
              then fail();
      
            else (inExp);
      
          end matchcontinue;
      
        end replaceDerCall;
      
        protected function tryToSolveOrDerive
      
          input DAE.Exp e;
      
          input DAE.ComponentRef cr "x";
      
          input BackendDAE.Variables vars;
      
          input Option<AvlTreePathFunction.Tree> functions;
      
          input Boolean trytosolve1 "if true, try to solve the expression for the variable, even if flag 'allowImpossibleAssignments' is not set";
      
          output DAE.Exp f;
      
          output Boolean solved=false "true if equation is solved for the variable with ExpressionSolve.solve2, false if equation is differentiated";
      
          output Boolean derived=false;
      
          output BackendDAE.Constraints outCons={};
      
        protected
      
          DAE.Type tp = Expression.typeof(e);
      
          Boolean trytosolve2 = stringEqual(Flags.getConfigString(Flags.TEARING_STRICTNESS), "casual");
      
          Boolean localCon;
      
          DAE.Exp one, tmpEqn, solvedExp, con;
      
          list<BackendDAE.Equation> eqnForNewVars;
      
          list<DAE.ComponentRef> newVarsCrefs;
      
          DAE.ComponentRef tmpVar;
      
          DAE.Constraint constraint;
      
          BackendDAE.Constraints constraints;
      
          constant Boolean debug = false;
      
        algorithm
      
          2/2✓ Branch 0 taken 3136 times.
✓ Branch 1 taken 105544 times.

        108680
          if trytosolve1 or trytosolve2 then
      
            try // try to solve for x (1*x = f(y))
      
        3136
              (solvedExp,_,eqnForNewVars,newVarsCrefs) := ExpressionSolve.solve2(e, Expression.makeConstZero(tp),Expression.crefExp(cr), functions, SOME(1));
      
              if debug then
      
                print("Solve expression:\n" + ExpressionBasics.printExpStr(e) + "\n");
      
                print("for variable: " + ExpressionBasics.printExpStr(Expression.crefExp(cr)) + "\n");
      
                print("Solved expression:\n" + ExpressionBasics.printExpStr(solvedExp) + "\n");
      
                ComponentReference.printComponentRefList(newVarsCrefs);
      
                BackendDump.dumpEquationList(eqnForNewVars, "eqnForNewVars");
      
                ExpressionDump.dumpExp(solvedExp);
      
                print("listLength(eqnForNewVars): " + intString(listLength(eqnForNewVars)) + "\n\n");
      
              end if;
      
          2/2✓ Branch 0 taken 2960 times.
✓ Branch 1 taken 64 times.

        3024
              if trytosolve1 then
      
        2960
                (_,(constraints,_)) := Expression.traverseExpTopDown(solvedExp, getConstraints, ({},vars));
      
          2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 2959 times.

        2980
                for eqn in eqnForNewVars loop
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 20 times.

        21
                  BackendDAE.SOLVED_EQUATION(componentRef=tmpVar, exp=tmpEqn) := eqn;
      
        20
                  (_,(constraints,_)) := Expression.traverseExpTopDown(tmpEqn, getConstraints, (constraints,vars));
      
                end for;
      
          2/2✓ Branch 1 taken 1676 times.
✓ Branch 2 taken 1283 times.

        4635
                for i in listLength(constraints):-1:1 loop
      
        1676
                  constraint := listGet(constraints, i);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1676 times.

        1676
                  DAE.CONSTRAINT_DT(constraint = con, localCon=localCon) := constraint;
      
          2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 1676 times.

        1696
                  for eqn in eqnForNewVars loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.

        20
                    BackendDAE.SOLVED_EQUATION(componentRef=tmpVar, exp=tmpEqn) := eqn;
      
        20
                    con := Expression.replaceCrefBottomUp(con, tmpVar, tmpEqn);
      
                  end for;
      
          2/2✓ Branch 0 taken 1640 times.
✓ Branch 1 taken 36 times.

        3316
                  outCons := DAE.CONSTRAINT_DT(con, localCon)::outCons;
      
                end for;
      
                if debug then
      
                  print("Constraints before substitution: " + ExpressionDump.constraintDTlistToString(constraints, "\n") + "\n\n");
      
                  print("Substituted expression:\n" + ExpressionBasics.printExpStr(solvedExp) + "\n");
      
                  print("Constraints:" + ExpressionDump.constraintDTlistToString(outCons, "\n") + "\n\n");
      
                end if;
      
              end if;
      
              solved := true;
      
            else end try;
      
          end if;
      
          try
      
        108680
          f := Differentiate.differentiateExpSolve(e, cr, functions);
      
          f := match f
      
                /* der(f(x)) = c/y => c*x = y*lhs */
      
                case DAE.BINARY(one,DAE.DIV(), DAE.CREF()) /*Note: 1/x => ln(x) => Expression.solve will solve it */
      
                  guard Expression.isConst(one) and not Expression.isZero(one)
      
                then one;
      
                else f;
      
              end match;
      
           derived := true;
      
           else
      
        6877
              f := Expression.makeConstOne(tp);
      
           end try;
      
          2/2✓ Branch 1 taken 2239 times.
✓ Branch 2 taken 106441 times.

        108680
           if Expression.isZero(f) then
      
            // see https://trac.openmodelica.org/OpenModelica/ticket/3742#comment:12
      
            // ExpressionSolve will fail for f == 0 --> internal loops inside tearing
      
        2239
            fail();
      
           end if;
      
          2/2✓ Branch 0 taken 6877 times.
✓ Branch 1 taken 99564 times.

        106441
           true := solved or derived;
      
           if debug then
      
             if solved then
      
               print("[SOLVED] ");
      
             elseif derived then
      
               print("[DERIVED] ");
      
             else
      
               print("[?BROKEN?] ");
      
             end if;
      
             print("tryToSolveOrDerive " + ExpressionBasics.printExpStr(e) + " -> " +  ExpressionBasics.printExpStr(f) + " == " + ExpressionBasics.printExpStr(Expression.crefExp(cr)) + "\n");
      
           end if;
      
        end tryToSolveOrDerive;
      
        public function isSolvable
      
          input BackendDAE.Solvability solvability;
      
          input Boolean strict = false;
      
          output Boolean solvable;
      
        algorithm
      
          solvable := match solvability
      
            local
      
              Boolean b;
      
            case BackendDAE.SOLVABILITY_NONLINEAR() then false;
      
            case BackendDAE.SOLVABILITY_UNSOLVABLE() then false;
      
            case BackendDAE.SOLVABILITY_CONST(b=b) then b;
      
            case BackendDAE.SOLVABILITY_PARAMETER(b=b) then b;
      
        ✗
            case BackendDAE.SOLVABILITY_LINEAR(b=b) then (b and not strict);
      
            else true;
      
          end match;
      
        end isSolvable;
      
        protected function getConstraints "
      
        author: ptaeuber
      
        Function to find the constraints for Dynamic Tearing."
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Constraints,BackendDAE.Variables> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont=true;
      
          output tuple<BackendDAE.Constraints,BackendDAE.Variables> outTpl;
      
        protected
      
          BackendDAE.Constraints inCons;
      
          BackendDAE.Variables vars;
      
        algorithm
      
        78996
          (inCons,vars) := inTpl;
      
          (outExp,outTpl) := match inExp
      
            local
      
              DAE.Exp e;
      
              DAE.Exp rel;
      
              DAE.Constraint con;
      
              list<DAE.ComponentRef> crlst;
      
              Boolean localCon;
      
            case DAE.BINARY(operator=DAE.DIV(), exp2=e)
      
              algorithm
      
        1654
                rel := DAE.RELATION(DAE.CALL(Absyn.IDENT("abs"), {e}, DAE.callAttrBuiltinOther), DAE.GREATER(DAE.T_REAL_DEFAULT), DAE.RCONST(1e-12), -1, NONE());
      
        1654
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        1654
                localCon := containAnyVarWithoutStates(crlst,vars);
      
          2/2✓ Branch 0 taken 1640 times.
✓ Branch 1 taken 14 times.

        3294
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        1654
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "sqrt"), expLst = {e})
      
              algorithm
      
        ✗
                rel := DAE.RELATION(e, DAE.GREATEREQ(DAE.T_REAL_DEFAULT), DAE.RCONST(0.0), -1, NONE());
      
        ✗
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        ✗
                localCon := containAnyVarWithoutStates(crlst,vars);
      
        ✗
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        ✗
             then (inExp,(con::inCons,vars));
      
            case DAE.BINARY(exp1=e, operator=DAE.POW(), exp2=DAE.RCONST(0.5))
      
              algorithm
      
        20
                rel := DAE.RELATION(e, DAE.GREATEREQ(DAE.T_REAL_DEFAULT), DAE.RCONST(0.0), -1, NONE());
      
        20
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        20
                localCon := containAnyVarWithoutStates(crlst,vars);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.

        20
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        20
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "log"), expLst = {e})
      
              algorithm
      
        2
                rel := DAE.RELATION(e, DAE.GREATER(DAE.T_REAL_DEFAULT), DAE.RCONST(1e-12), -1, NONE());
      
        2
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        2
                localCon := containAnyVarWithoutStates(crlst,vars);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

        2
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        2
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "log10"), expLst = {e})
      
              algorithm
      
        ✗
                rel := DAE.RELATION(e, DAE.GREATER(DAE.T_REAL_DEFAULT), DAE.RCONST(1e-12), -1, NONE());
      
        ✗
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        ✗
                localCon := containAnyVarWithoutStates(crlst,vars);
      
        ✗
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        ✗
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "asin"), expLst = {e})
      
              algorithm
      
        ✗
                rel := DAE.RELATION(DAE.CALL(Absyn.IDENT("abs"), {e}, DAE.callAttrBuiltinOther), DAE.LESSEQ(DAE.T_REAL_DEFAULT), DAE.RCONST(1.0), -1, NONE());
      
        ✗
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        ✗
                localCon := containAnyVarWithoutStates(crlst,vars);
      
        ✗
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        ✗
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "acos"), expLst = {e})
      
              algorithm
      
        ✗
                rel := DAE.RELATION(DAE.CALL(Absyn.IDENT("abs"), {e}, DAE.callAttrBuiltinOther), DAE.LESSEQ(DAE.T_REAL_DEFAULT), DAE.RCONST(1.0), -1, NONE());
      
        ✗
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        ✗
                localCon := containAnyVarWithoutStates(crlst,vars);
      
        ✗
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        ✗
             then (inExp,(con::inCons,vars));
      
            case DAE.CALL(path = Absyn.IDENT(name = "tan"), expLst = {e})
      
              algorithm
      
        ✗
                rel := DAE.RELATION(DAE.BINARY(exp1=DAE.CALL(Absyn.IDENT("abs"), {DAE.BINARY(exp1=DAE.BINARY(exp1=e, operator=DAE.DIV(ty=DAE.T_REAL_DEFAULT), exp2=DAE.RCONST(3.14159265358979)), operator=DAE.MUL(ty=DAE.T_REAL_DEFAULT), exp2=DAE.RCONST(2.0))}, DAE.callAttrBuiltinOther), operator=DAE.SUB(ty=DAE.T_REAL_DEFAULT), exp2=DAE.CALL(Absyn.IDENT("floor"), {DAE.CALL(Absyn.IDENT("abs"), {DAE.BINARY(exp1=DAE.BINARY(exp1=e, operator=DAE.DIV(ty=DAE.T_REAL_DEFAULT), exp2=DAE.RCONST(3.14159265358979)), operator=DAE.MUL(ty=DAE.T_REAL_DEFAULT), exp2=DAE.RCONST(2.0))}, DAE.callAttrBuiltinOther)}, DAE.callAttrBuiltinOther)), DAE.GREATER(DAE.T_REAL_DEFAULT), DAE.RCONST(1e-12), -1, NONE());
      
        ✗
                (_,crlst) := Expression.traverseExpTopDown(rel, Expression.traversingComponentRefFinderNoPreDer, {});
      
        ✗
                localCon := containAnyVarWithoutStates(crlst,vars);
      
        ✗
                con := DAE.CONSTRAINT_DT(rel,localCon);
      
        ✗
             then (inExp,(con::inCons,vars));
      
            else
      
             then (inExp,inTpl);
      
          end match;
      
        end getConstraints;
      
        public function getEqnAndVarsFromInnerEquation
      
          "author: ptaeuber
      
           Returns the equation and the variables from BackendDAE record INNEREQUATION
      
           or the equation, variables and constraints from INNEREQUATIONCONSTRAINTS."
      
          input BackendDAE.InnerEquation innerEquation;
      
          output Integer outEqn;
      
          output list<Integer> outVars;
      
          output BackendDAE.Constraints outCons;
      
        algorithm
      
          (outEqn,outVars,outCons) := match innerEquation
      
            local
      
              Integer eqn;
      
              list<Integer> vars;
      
              BackendDAE.Constraints cons;
      
            case BackendDAE.INNEREQUATION(eqn=eqn, vars=vars) then (eqn,vars,{});
      
            case BackendDAE.INNEREQUATIONCONSTRAINTS(eqn=eqn, vars=vars, cons=cons) then (eqn,vars,cons);
      
          end match;
      
        end getEqnAndVarsFromInnerEquation;
      
        public function getEqnAndVarsFromInnerEquationLst
      
          input BackendDAE.InnerEquations innerEquations;
      
          output list<Integer> eqns = {};
      
          output list<list<Integer>> allVars = {};
      
          output list<BackendDAE.Constraints> allConstraints = {};
      
        protected
      
          Integer eqn;
      
          list<Integer> vars;
      
          BackendDAE.Constraints constraints;
      
        algorithm
      
        ✗
          for innerEq in innerEquations loop
      
        ✗
            (eqn,vars,constraints) := getEqnAndVarsFromInnerEquation(innerEq);
      
            eqns := eqn::eqns;
      
        ✗
            if isPresent(allVars) then allVars := vars::allVars; end if;
      
        ✗
            if isPresent(allConstraints) then allConstraints := constraints::allConstraints; end if;
      
          end for;
      
        end getEqnAndVarsFromInnerEquationLst;
      
        protected function transformSolvabilityForCasualTearingSet
      
          input BackendDAE.Solvability inSolvab;
      
          output BackendDAE.Solvability outSolvab;
      
        algorithm
      
          outSolvab := match inSolvab
      
            case BackendDAE.SOLVABILITY_CONST(b=false) then BackendDAE.SOLVABILITY_CONST(false);
      
            case BackendDAE.SOLVABILITY_PARAMETER(b=false) then BackendDAE.SOLVABILITY_PARAMETER(false);
      
            case BackendDAE.SOLVABILITY_LINEAR(b=false) then BackendDAE.SOLVABILITY_LINEAR(false);
      
            else BackendDAE.SOLVABILITY_SOLVABLE();
      
          end match;
      
        end transformSolvabilityForCasualTearingSet;
      
        protected function expCrefLstHasCref
      
          input list<DAE.Exp> iExpLst;
      
          input DAE.ComponentRef inCr;
      
          output Boolean outB;
      
        algorithm
      
          outB := matchcontinue iExpLst
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.Exp> rest;
      
              Boolean b;
      
            case {} then false;
      
            case DAE.CREF(componentRef=cr)::rest
      
              algorithm
      
        15713
                b := ComponentReferenceBasics.crefEqualNoStringCompare(cr,inCr);
      
          2/2✓ Branch 0 taken 13567 times.
✓ Branch 1 taken 2146 times.

        15713
                b := if not b then expCrefLstHasCref(rest, inCr) else b;
      
              then
      
                b;
      
            else
      
              then
      
                false;
      
          end matchcontinue;
      
        end expCrefLstHasCref;
      
        protected function adjacencyRowEnhanced2
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyRowEnhanced. Calculates the
      
          solvability of the variables."
      
          input DAE.ComponentRef cr;
      
          input DAE.Exp e;
      
          input list<DAE.ComponentRef> crlst;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.Variables globalKnownVars;
      
          output BackendDAE.Solvability oSolvab;
      
        algorithm
      
          oSolvab := match crlst
      
            local
      
              Boolean b1,b2;
      
            case {}
      
              algorithm
      
        38950
                b1 := Expression.isZeroOrAlmostZero(e);
      
          4/4✓ Branch 1 taken 23945 times.
✓ Branch 2 taken 15005 times.
✓ Branch 4 taken 6352 times.
✓ Branch 5 taken 17593 times.

        38950
                b2 := Expression.isConstOne(e) or Expression.isConstMinusOne(e);
      
          2/2✓ Branch 0 taken 237 times.
✓ Branch 1 taken 6115 times.

        6589
              then
      
                if b2 then BackendDAE.SOLVABILITY_CONSTONE() else BackendDAE.SOLVABILITY_CONST(not b1);
      
            case _ guard List.isMemberOnTrue(cr,crlst,ComponentReferenceBasics.crefEqualNoStringCompare)
      
              then
      
                BackendDAE.SOLVABILITY_NONLINEAR();
      
            case _
      
              algorithm
      
        49360
                b1 := containAnyVar(crlst,globalKnownVars);
      
        49360
                b2 := containAnyVar(crlst,vars);
      
        49360
              then
      
                adjacencyRowEnhanced3(b1,b2,cr,e,crlst,vars,globalKnownVars);
      
          end match;
      
        end adjacencyRowEnhanced2;
      
        protected function adjacencyRowEnhanced3
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyRowEnhanced. Calculates the
      
          solvability of the variables."
      
          input Boolean b1;
      
          input Boolean b2;
      
          input DAE.ComponentRef cr;
      
          input DAE.Exp e;
      
          input list<DAE.ComponentRef> crlst;
      
          input BackendDAE.Variables vars;
      
          input BackendDAE.Variables globalKnownVars;
      
          output BackendDAE.Solvability oSolvab;
      
        algorithm
      
          oSolvab := match(b1, b2)
      
            local
      
              Boolean b,b_1;
      
              DAE.Exp e1, nominal;
      
            case(true, true)
      
              algorithm
      
        3324
                (e1,_) := Expression.traverseExpBottomUp(e, replaceVarWithValue, globalKnownVars);
      
        3324
                (e1,_) := ExpressionSimplify.simplify(e1);
      
        3324
                b := not Expression.isZeroOrAlmostZero(e1);
      
          2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 3312 times.

        3336
              then
      
               BackendDAE.SOLVABILITY_LINEAR(b);
      
            case(false, _)
      
              algorithm
      
        31534
                b := not Expression.isZeroOrAlmostZero(e);
      
          2/2✓ Branch 0 taken 41 times.
✓ Branch 1 taken 31493 times.

        31575
              then
      
                BackendDAE.SOLVABILITY_LINEAR(b);
      
            case(true, _)
      
              algorithm
      
        14502
                (nominal,_) := Expression.traverseExpBottomUp(e, replaceVarWithNominal, globalKnownVars);
      
        14502
                (nominal,_) := ExpressionSimplify.simplify(nominal);
      
        14502
                (e1,_) := Expression.traverseExpBottomUp(e, replaceVarWithValue, globalKnownVars);
      
        14502
                (e1,_) := ExpressionSimplify.simplify(e1);
      
        14502
                b := not Expression.isZeroOrAlmostZero(e1, nominal);
      
          4/4✓ Branch 1 taken 4542 times.
✓ Branch 2 taken 9960 times.
✓ Branch 4 taken 244 times.
✓ Branch 5 taken 4298 times.

        14502
                b_1 := Expression.isConst(e1) or BackendVariable.isKnownAndParam(e1,globalKnownVars);
      
          3/4✓ Branch 0 taken 2512 times.
✓ Branch 1 taken 7692 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4298 times.

        17014
              then
      
               if b_1 then BackendDAE.SOLVABILITY_PARAMETER(b) else BackendDAE.SOLVABILITY_LINEAR(b);
      
            case(_, _)
      
              algorithm
      
        ✗
                b := not Expression.isZeroOrAlmostZero(e);
      
        ✗
              then
      
                BackendDAE.SOLVABILITY_LINEAR(b);
      
          end match;
      
        end adjacencyRowEnhanced3;
      
        public function replaceVarWithValue
      
        "Helper function to adjacencyRowEnhanced3. Traverser to replace variables(parameters) with their bind expression."
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVars;
      
          output DAE.Exp outExp;
      
          output BackendDAE.Variables outVars;
      
        algorithm
      
          (outExp,outVars) := matchcontinue (inExp,inVars)
      
            local
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              BackendDAE.Var v;
      
              DAE.Exp e;
      
            case (DAE.CREF(componentRef=cr),vars)
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 98569 times.

        110773
                (v::_,_) := BackendVariable.getVar(cr,vars);
      
        98569
                e := BackendVariable.varBindExp(v);
      
        97741
                (e,_) := Expression.traverseExpBottomUp(e, replaceVarWithValue, vars);
      
              then (e, vars);
      
            case (DAE.CREF(componentRef=cr),vars)
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 828 times.

        13032
                (v::_,_) := BackendVariable.getVar(cr,vars);
      
          2/2✓ Branch 1 taken 710 times.
✓ Branch 2 taken 118 times.

        828
                true := BackendVariable.varFixed(v);
      
        118
                e := BackendVariable.varBindExpStartValue(v);
      
        118
                (e,_) := Expression.traverseExpBottomUp(e, replaceVarWithValue, vars);
      
              then (e, vars);
      
            else (inExp,inVars);
      
          end matchcontinue;
      
        end replaceVarWithValue;
      
        protected function replaceVarWithNominal
      
        "Helper function to adjacencyRowEnhanced3. Traverser to replace variables(parameters) with their nominal values."
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVars;
      
          output DAE.Exp outExp;
      
          output BackendDAE.Variables outVars;
      
        algorithm
      
          (outExp,outVars) := matchcontinue (inExp,inVars)
      
            local
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              BackendDAE.Var v;
      
              DAE.Exp nom;
      
            case (DAE.CREF(componentRef=cr),vars)
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 20452 times.

        25885
                (v::_,_) := BackendVariable.getVar(cr,vars);
      
        20452
                nom := BackendVariable.getVarNominalValue(v);
      
        20452
                (nom,_) := Expression.traverseExpBottomUp(nom, replaceVarWithNominal, vars);
      
              then (nom, vars);
      
            else (inExp,inVars);
      
          end matchcontinue;
      
        end replaceVarWithNominal;
      
        protected function adjacencyRowExpEnhanced
      
        "author: Frenkel TUD 2012-05
      
          Helper function to adjacencyRowEnhanced, investigates expressions for
      
          variables, returning variable indexes, and mark the solvability."
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVariables;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input Boolean isInitial;
      
          input list<Integer> inRow;
      
          output list<Integer> outRow;
      
        algorithm
      
          2/2✓ Branch 0 taken 51787 times.
✓ Branch 1 taken 47674 times.

        151248
          (_,(_,_,_,_,_,outRow)) := Expression.traverseExpTopDown(inExp, traversingAdjacencyRowExpSolvableEnhancedFinder, (inVariables,false,isInitial,mark,rowmark,inRow));
      
        end adjacencyRowExpEnhanced;
      
        protected function traversingAdjacencyRowExpSolvableEnhancedFinder "Helper for adjacencyRowExpEnhanced"
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables, Boolean, Boolean, Integer, array<Integer>, list<Integer>> inTpl "(exp, (variables, unsolvable, mark, rowmark, row))";
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables, Boolean, Boolean, Integer, array<Integer>, list<Integer>> outTpl;
      
        algorithm
      
          (outExp, cont, outTpl) := matchcontinue (inExp, inTpl)
      
            local
      
              list<Integer> p, pa, res;
      
              DAE.ComponentRef cr;
      
              BackendDAE.Variables vars;
      
              DAE.Exp e1, e2, e3;
      
              list<BackendDAE.Var> varslst;
      
              Boolean b, b1, b2, bs, isInitial;
      
              Integer mark, i;
      
              array<Integer> rowmark;
      
              Integer it;
      
              array<Integer> at;
      
              tuple<BackendDAE.Variables, Boolean, Boolean, Integer, array<Integer>, list<Integer>> tpl;
      
            case (DAE.LUNARY(exp=e1), (vars, bs, isInitial, it, at, pa)) algorithm
      
          4/4✓ Branch 0 taken 248 times.
✓ Branch 1 taken 292 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 512 times.

        816
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, bs, isInitial, it, at, pa));
      
        540
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.LBINARY(exp1=e1, exp2=e2), (vars, bs, isInitial, it, at, pa)) algorithm
      
          2/2✓ Branch 0 taken 722 times.
✓ Branch 1 taken 4027 times.

        5471
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        4749
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e2, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
          2/2✓ Branch 0 taken 179 times.
✓ Branch 1 taken 4570 times.

        4928
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.RELATION(exp1=e1, exp2=e2), (vars, bs, isInitial, it, at, pa)) algorithm
      
          2/2✓ Branch 0 taken 1655 times.
✓ Branch 1 taken 6968 times.

        10278
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        8623
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e2, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
          2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 8565 times.

        8681
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.IFEXP(), (vars, bs, isInitial, it, at, pa))
      
          3/4✓ Branch 0 taken 1751 times.
✓ Branch 1 taken 3828 times.
✓ Branch 2 taken 5579 times.
✗ Branch 3 not taken.

        12909
            then traversingAdjacencyRowIfExpEnhanced(inExp, (vars, bs, isInitial, it, at, pa), traversingAdjacencyRowExpSolvableEnhancedFinder);
      
            case (DAE.RANGE(start=e1, step=NONE(), stop=e2), (vars, bs, isInitial, it, at, pa)) algorithm
      
          2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.

        15
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        10
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e2, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
          1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.

        20
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.RANGE(start=e1, step=SOME(e3), stop=e2), (vars, bs, isInitial, it, at, pa)) algorithm
      
        ✗
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        ✗
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e2, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        ✗
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e3, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, true, isInitial, it, at, pa));
      
        ✗
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.ASUB(exp=e1, sub={DAE.INDEX(DAE.ICONST(i))}), (vars, bs, isInitial, it, at, pa)) algorithm
      
        31
              e1 := Expression.nthArrayExp(e1, i);
      
          3/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 31 times.
✗ Branch 3 not taken.

        78
              (_, (vars, _, _, _, _, pa)) := Expression.traverseExpTopDown(e1, traversingAdjacencyRowExpSolvableEnhancedFinder, (vars, bs, isInitial, it, at, pa));
      
        31
            then (inExp, false, (vars, bs, isInitial, it, at, pa));
      
            case (DAE.ASUB(), _)
      
            then fail();
      
            case (DAE.CREF(componentRef=cr), (vars, bs, isInitial, it, at, pa)) algorithm
      
              mark := it;
      
              rowmark := at;
      
        296848
              (varslst, p) := BackendVariable.getVar(cr, vars);
      
        192104
              res := adjacencyRowExpEnhanced1(varslst, p, pa, true, mark, rowmark, bs);
      
          4/4✓ Branch 0 taken 79045 times.
✓ Branch 1 taken 113059 times.
✓ Branch 2 taken 178522 times.
✓ Branch 3 taken 13582 times.

        449671
            then (inExp, false, (vars, bs, isInitial, it, at, res));
      
            case (DAE.CALL(path=Absyn.IDENT(name="der"), expLst={DAE.CREF(componentRef=cr)}), (vars, bs, isInitial, it, at, pa)) algorithm
      
              mark := it;
      
              rowmark := at;
      
        2384
              (varslst, p) := BackendVariable.getVar(cr, vars);
      
        2043
              res := adjacencyRowExpEnhanced1(varslst, p, pa, false, mark, rowmark, bs);
      
          2/4✓ Branch 0 taken 2043 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2043 times.
✗ Branch 3 not taken.

        6129
            then (inExp, false, (vars, bs, isInitial, it, at, res));
      
            case (DAE.CALL(path=Absyn.IDENT(name="der"), expLst={DAE.CREF(componentRef=cr), DAE.ICONST(_)}), (vars, bs, isInitial, it, at, pa)) algorithm
      
              mark := it;
      
              rowmark := at;
      
        ✗
              (varslst, p) := BackendVariable.getVar(cr, vars);
      
        ✗
              res := adjacencyRowExpEnhanced1(varslst, p, pa, false, mark, rowmark, bs);
      
        ✗
            then (inExp, false, (vars, bs, isInitial, it, at, res));
      
            // pre(v) is considered a known variable
      
            case (DAE.CALL(path=Absyn.IDENT(name="pre"), expLst={DAE.CREF()}),  _)
      
        226
            then (inExp, false, inTpl);
      
            // previous(v) is considered a known variable
      
            case (DAE.CALL(path=Absyn.IDENT(name="previous"), expLst={DAE.CREF()}),  _)
      
        ✗
            then (inExp, false, inTpl);
      
            // delay(e) can be used to break algebraic loops given some solver options
      
            case (DAE.CALL(path=Absyn.IDENT(name="delay"), expLst={_, _, e1, e2}),  _) algorithm
      
        ✗
              b := Flags.getConfigBool(Flags.DELAY_BREAK_LOOP) and ExpressionBasics.expEqual(e1, e2);
      
        ✗
            then (inExp, not b, inTpl);
      
            // homotopy operator for simulation system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, _}), (_, _, false, _, _, _))
      
        ✗
            then traversingAdjacencyRowExpSolvableEnhancedFinder(e1, inTpl);
      
            // homotopy operator for initialization system
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, e2}), (_, _, true, _, _, _))
      
              algorithm
      
        259
                (_, b1, tpl) := traversingAdjacencyRowExpSolvableEnhancedFinder(e1, inTpl);
      
        259
                (_, b2, tpl) := traversingAdjacencyRowExpSolvableEnhancedFinder(e2, tpl);
      
          4/4✓ Branch 0 taken 241 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 235 times.

        283
            then (inExp, b1 and b2, tpl);
      
            // only traverse position and direction for spatialDistribution, not the inputs!
      
            case (DAE.CALL(path=Absyn.IDENT(name="spatialDistribution"), expLst = {_, _, _, e1, e2, _, _}), _)
      
              algorithm
      
        ✗
                (_, _, tpl) := traversingAdjacencyRowExpSolvableEnhancedFinder(e2, inTpl);
      
        ✗
            then traversingAdjacencyRowExpSolvableEnhancedFinder(e1, tpl);
      
        539941
            else (inExp, true, inTpl);
      
          end matchcontinue;
      
        end traversingAdjacencyRowExpSolvableEnhancedFinder;
      
        protected function markBranchVars "mark all vars of a if expression which are not in all branches as unsolvable"
      
          input DAE.Exp inExp;
      
          input tuple<Integer,array<Integer>,BackendDAE.Variables,BinaryTree.BinTree> inTuple;
      
          output DAE.Exp outExp;
      
          output Boolean cont=true;
      
          output tuple<Integer,array<Integer>,BackendDAE.Variables,BinaryTree.BinTree> outTuple;
      
        algorithm
      
          (outExp, cont, outTuple) := matchcontinue (inExp,inTuple)
      
            local
      
              BackendDAE.Variables vars;
      
              DAE.ComponentRef cr;
      
              BinaryTree.BinTree bt;
      
              list<Integer> ilst;
      
              Integer mark;
      
              array<Integer> rowmark;
      
              list<BackendDAE.Var> backendVars;
      
            // special case for time, it is never part of the equation system
      
            case (DAE.CREF(componentRef = DAE.CREF_IDENT(ident="time")),_)
      
              then (inExp, false, inTuple);
      
            // case for functionpointers
      
            case (DAE.CREF(ty=DAE.T_FUNCTION_REFERENCE_FUNC()),_)
      
              then (inExp, false, inTuple);
      
            case (DAE.CALL(path = Absyn.IDENT(name = "pre"),expLst = {DAE.CREF()}),_)
      
              then (inExp, false, inTuple);
      
            case (DAE.CALL(path = Absyn.IDENT(name = "previous"),expLst = {DAE.CREF()}),_)
      
              then (inExp, false, inTuple);
      
            // mark if not in bt
      
            case (DAE.CREF(componentRef = cr),(mark,rowmark,vars,bt))
      
              algorithm
      
        117220
                 (backendVars,ilst) := BackendVariable.getVar(cr, vars);
      
        97647
                 markBranchVars1(backendVars,ilst,mark,rowmark,bt);
      
              then (inExp, true, inTuple);
      
            else (inExp, true, inTuple);
      
          end matchcontinue;
      
        end markBranchVars;
      
        protected function markBranchVars1
      
        "Author: Frenkel TUD 2012-09
      
          Helper for markBranchVars"
      
          input list<BackendDAE.Var> varlst;
      
          input list<Integer> iIlst;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input BinaryTree.BinTree bt;
      
        algorithm
      
          () := matchcontinue(varlst, iIlst)
      
            local
      
              DAE.ComponentRef cr;
      
             list<BackendDAE.Var> vlst;
      
             Integer i;
      
             list<Integer> ilst;
      
            case({}, _) then ();
      
            case(BackendDAE.VAR(varName=cr)::vlst, _::ilst)
      
              algorithm
      
        97647
                BinaryTree.treeGet(bt,cr);
      
        44755
                markBranchVars1(vlst,ilst,mark,rowmark,bt);
      
              then
      
                ();
      
            case(_::vlst, i::ilst)
      
              algorithm
      
        52892
                arrayUpdate(rowmark,i,-mark);
      
        52892
                markBranchVars1(vlst,ilst,mark,rowmark,bt);
      
              then
      
                ();
      
          end matchcontinue;
      
        end markBranchVars1;
      
        protected function getIfExpBranchVarOccurency "Helper for getIfExpBranchVarOccurency"
      
          input DAE.Exp inExp;
      
          input BinaryTree.BinTree inBt;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output BinaryTree.BinTree bt;
      
        algorithm
      
          (outExp,cont,bt) := match (inExp,inBt)
      
            local
      
              DAE.ComponentRef cr;
      
              DAE.Exp e,e1,e2;
      
              BinaryTree.BinTree bt_then,bt_else;
      
              Boolean b;
      
            case (e as DAE.IFEXP(expThen = e1,expElse = e2),bt)
      
              algorithm
      
        11145
                (_,bt_then) := Expression.traverseExpTopDown(e1,getIfExpBranchVarOccurency,BinaryTree.emptyBinTree);
      
        11145
                (_,bt_else) := Expression.traverseExpTopDown(e2,getIfExpBranchVarOccurency,BinaryTree.emptyBinTree);
      
        11145
                bt := BinaryTree.binTreeintersection(bt_then,bt_else,bt);
      
              then (e,false,bt);
      
            // skip relations,ranges,asubs
      
            case (e as DAE.LUNARY(),bt)
      
              then (e,false,bt);
      
            case (e as DAE.LBINARY(),bt)
      
              then (e,false,bt);
      
            case (e as DAE.RELATION(),bt)
      
              then (e,false,bt);
      
            case (e as DAE.RANGE(),bt)
      
              then (e,false,bt);
      
            case (e as DAE.RANGE(),bt)
      
              then (e,false,bt);
      
            case (e as DAE.ASUB(exp = e1),bt)
      
              algorithm
      
        ✗
                (_,bt) := Expression.traverseExpTopDown(e1, getIfExpBranchVarOccurency, bt);
      
        ✗
              then (e,false,bt);
      
            // add crefs
      
            case (e as DAE.CREF(componentRef = cr),bt)
      
              algorithm
      
        92639
                bt := BinaryTree.treeAdd(bt,cr,0);
      
              then (e,false,bt);
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),bt)
      
              algorithm
      
        426
                bt := BinaryTree.treeAdd(bt,cr,0);
      
              then (e,false,bt);
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "der"),expLst = {DAE.CREF(componentRef = cr)}),bt)
      
              algorithm
      
        ✗
                bt := BinaryTree.treeAdd(bt,cr,0);
      
              then (e,false,bt);
      
            // pre(v) is considered a known variable
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "pre"),expLst = {DAE.CREF()}),bt)
      
              then (e,false,bt);
      
            // previous(v) is considered a known variable
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "previous"),expLst = {DAE.CREF()}),bt)
      
              then (e,false,bt);
      
            // delay(e) can be used to break algebraic loops given some solver options
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "delay"),expLst = {_,_,e1,e2}),bt)
      
              algorithm
      
        ✗
                b := Flags.getConfigBool(Flags.DELAY_BREAK_LOOP) and ExpressionBasics.expEqual(e1,e2);
      
        ✗
              then (e,not b,bt);
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst = {e1, _}), _) algorithm
      
            // phi: what about e2?
      
        ✗
            then getIfExpBranchVarOccurency(e1, inBt);
      
            else (inExp,true,inBt);
      
          end match;
      
        end getIfExpBranchVarOccurency;
      
        protected function adjacencyRowExpEnhanced1
      
        "author: Frenkel TUD 2012-05
      
          Helper function to traversingAdjacencyRowExpSolvableEnhancedFinder, fill the variable indexes
      
          in the list and update the array to mark the variables."
      
          input list<BackendDAE.Var> inVarLst;
      
          input list<Integer> inIntegerLst;
      
          input list<Integer> vars;
      
          input Boolean notinder;
      
          input Integer mark;
      
          input array<Integer> rowmark;
      
          input Boolean unsolvable;
      
          output list<Integer> outIntegerLst;
      
        algorithm
      
          outIntegerLst := matchcontinue (inVarLst, inIntegerLst, notinder, unsolvable)
      
            local
      
               list<BackendDAE.Var> rest;
      
               list<Integer> irest,res;
      
               Integer i,i1;
      
               Boolean b,b1;
      
            case ({}, {}, _, _) then vars;
      
            /*If variable x is a state, der(x) is a variable in adjacency matrix,
      
                 x is inserted as negative value, since it is needed by debugging and
      
                 index reduction using dummy derivatives */
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE())::rest, i::irest, false, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2031 times.

        2031
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        2031
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE())::rest, i::irest, true, _)
      
              algorithm
      
        42399
                i1 := -i;
      
          2/2✓ Branch 0 taken 42399 times.
✓ Branch 1 taken 41404 times.

        83803
                failure(List.getMemberOnTrue(i1, vars, intEq));
      
        41404
                res := adjacencyRowExpEnhanced1(rest,irest,i1::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE_DER())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.

        8
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        8
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.STATE_DER())::rest, i::irest, _, true)
      
              algorithm
      
        ✗
                b := intEq(rowmark[i],mark);
      
        ✗
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
        ✗
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        ✗
                res := List.consOnTrue(not b, i, vars);
      
        ✗
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.VARIABLE())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          2/2✓ Branch 0 taken 1285 times.
✓ Branch 1 taken 92330 times.

        93615
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        93615
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.VARIABLE())::rest, i::irest, _, true)
      
              algorithm
      
        10748
                b := intEq(rowmark[i],mark);
      
        10748
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
          1/2✓ Branch 0 taken 10748 times.
✗ Branch 1 not taken.

        21496
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        10748
                res := List.consOnTrue(not b, i, vars);
      
        10748
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.ALG_STATE())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 486 times.

        490
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        490
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.ALG_STATE())::rest, i::irest, _, true)
      
              algorithm
      
        ✗
                b := intEq(rowmark[i],mark);
      
        ✗
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
        ✗
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        ✗
                res := List.consOnTrue(not b, i, vars);
      
        ✗
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          2/2✓ Branch 0 taken 522 times.
✓ Branch 1 taken 467 times.

        989
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        989
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DISCRETE())::rest, i::irest, _, true)
      
              algorithm
      
        11
                b := intEq(rowmark[i],mark);
      
        11
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
          1/2✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.

        22
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        11
                res := List.consOnTrue(not b, i, vars);
      
        11
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_DER())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11620 times.

        11620
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        11620
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_DER())::rest, i::irest, _, true)
      
              algorithm
      
        ✗
                b := intEq(rowmark[i],mark);
      
        ✗
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
        ✗
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        ✗
                res := List.consOnTrue(not b, i, vars);
      
        ✗
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_STATE())::rest, i::irest, _, _)
      
              guard
      
                not intEq(intAbs(rowmark[i]),mark)
      
              algorithm
      
          2/2✓ Branch 0 taken 170 times.
✓ Branch 1 taken 10599 times.

        10769
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        10769
                res := adjacencyRowExpEnhanced1(rest,irest,i::vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (BackendDAE.VAR(varKind = BackendDAE.DUMMY_STATE())::rest, i::irest, _, true)
      
              algorithm
      
        642
                b := intEq(rowmark[i],mark);
      
        642
                b1 := intEq(rowmark[i],-mark);
      
                b := b or b1;
      
          1/2✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.

        1284
                arrayUpdate(rowmark,i,if unsolvable then -mark else mark);
      
        642
                res := List.consOnTrue(not b, i, vars);
      
        642
                res := adjacencyRowExpEnhanced1(rest,irest,res,notinder,mark,rowmark,unsolvable);
      
              then res;
      
            case (_::rest, _::irest, _, _)
      
              algorithm
      
        22787
                res := adjacencyRowExpEnhanced1(rest,irest,vars,notinder,mark,rowmark,unsolvable);
      
              then res;
      
          end matchcontinue;
      
        end adjacencyRowExpEnhanced1;
      
        public function solvabilityWights
      
        "author: Frenkel TUD 2012-05,
      
          return a integer for the solvability, this function is used
      
          to calculade wights for variables "
      
          input BackendDAE.Solvability solva;
      
          output Integer i;
      
        algorithm
      
          i := match solva
      
            case BackendDAE.SOLVABILITY_SOLVED() then 1;
      
            case BackendDAE.SOLVABILITY_CONSTONE() then 2;
      
            case BackendDAE.SOLVABILITY_CONST() then 5;
      
            case BackendDAE.SOLVABILITY_PARAMETER(b=false) then 0;
      
            case BackendDAE.SOLVABILITY_PARAMETER(b=true) then 50;
      
            case BackendDAE.SOLVABILITY_LINEAR(b=false) then 0;
      
            case BackendDAE.SOLVABILITY_LINEAR(b=true) then 100;
      
            case BackendDAE.SOLVABILITY_NONLINEAR() then 500;
      
            case BackendDAE.SOLVABILITY_UNSOLVABLE() then 1000;
      
          end match;
      
        end solvabilityWights;
      
        public function solvabilityCMP
      
        "author: Frenkel TUD 2012-05,
      
          function to compare solvabilities in the way solvabilityA < solvabilityB with
      
          solved < constone < const < parameter < linear < nonlinear < unsolvable."
      
          input BackendDAE.Solvability sa;
      
          input BackendDAE.Solvability sb;
      
          output Boolean b;
      
        algorithm
      
          b := match(sa,sb)
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_SOLVED()) then false;
      
            case (_,BackendDAE.SOLVABILITY_SOLVED()) then true;
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_CONSTONE()) then false;
      
            case (BackendDAE.SOLVABILITY_CONSTONE(),BackendDAE.SOLVABILITY_CONSTONE()) then false;
      
            case (_,BackendDAE.SOLVABILITY_CONSTONE()) then true;
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_CONST()) then false;
      
            case (BackendDAE.SOLVABILITY_CONSTONE(),BackendDAE.SOLVABILITY_CONST()) then false;
      
            case (BackendDAE.SOLVABILITY_CONST(),BackendDAE.SOLVABILITY_CONST()) then false;
      
            case (_,BackendDAE.SOLVABILITY_CONST()) then true;
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_PARAMETER()) then false;
      
            case (BackendDAE.SOLVABILITY_CONSTONE(),BackendDAE.SOLVABILITY_PARAMETER()) then false;
      
            case (BackendDAE.SOLVABILITY_CONST(),BackendDAE.SOLVABILITY_PARAMETER()) then false;
      
            case (BackendDAE.SOLVABILITY_PARAMETER(),BackendDAE.SOLVABILITY_PARAMETER()) then false;
      
            case (_,BackendDAE.SOLVABILITY_PARAMETER()) then true;
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_LINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_CONSTONE(),BackendDAE.SOLVABILITY_LINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_CONST(),BackendDAE.SOLVABILITY_LINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_PARAMETER(),BackendDAE.SOLVABILITY_LINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_LINEAR(),BackendDAE.SOLVABILITY_LINEAR()) then false;
      
            case (_,BackendDAE.SOLVABILITY_LINEAR()) then true;
      
            case (BackendDAE.SOLVABILITY_SOLVED(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_CONSTONE(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_CONST(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_PARAMETER(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_LINEAR(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (BackendDAE.SOLVABILITY_NONLINEAR(),BackendDAE.SOLVABILITY_NONLINEAR()) then false;
      
            case (_,BackendDAE.SOLVABILITY_NONLINEAR()) then true;
      
            case (BackendDAE.SOLVABILITY_UNSOLVABLE(),BackendDAE.SOLVABILITY_UNSOLVABLE()) then false;
      
            case (BackendDAE.SOLVABILITY_UNSOLVABLE(),_) then true;
      
          end match;
      
        end solvabilityCMP;
      
        public function getArrayEquationSub"author: Frenkel TUD
      
          helper for calculateJacobianRow"
      
          input Integer Index;
      
          input list<Option<Integer>> inAD;
      
          input list<tuple<Integer,list<list<DAE.Subscript>>>> inList;
      
          output list<DAE.Subscript> outSubs;
      
          output list<tuple<Integer,list<list<DAE.Subscript>>>> outList;
      
        algorithm
      
          (outSubs,outList) :=
      
          matchcontinue (Index,inAD,inList)
      
            local
      
              Integer i,ie;
      
              list<Option<Integer>> ad;
      
              list<DAE.Subscript> subs,subs1;
      
              list<list<DAE.Subscript>> subslst,subslst1;
      
              list<tuple<Integer,list<list<DAE.Subscript>>>> rest,entrylst;
      
              tuple<Integer,list<list<DAE.Subscript>>> entry;
      
            // new entry
      
            case (i,ad,{})
      
              algorithm
      
        ✗
                subslst := Expression.dimensionSizesSubcriptsOpt(ad);
      
        ✗
                subs::subslst1 := Expression.rangesToSubscripts(subslst);
      
        ✗
              then
      
                (subs,{(i,subslst1)});
      
            // found last entry
      
            case (i,_,((ie,{subs}))::rest)
      
              guard
      
                intEq(i,ie)
      
              then
      
                (subs,rest);
      
            // found entry
      
            case (i,_,((ie,subs::subslst))::rest)
      
              guard
      
                intEq(i,ie)
      
        ✗
              then
      
                (subs,(ie,subslst)::rest);
      
            // next entry
      
            case (i,ad,(entry as (ie,_))::rest)
      
              guard
      
                not intEq(i,ie)
      
              algorithm
      
        ✗
                (subs1,entrylst) := getArrayEquationSub(i,ad,rest);
      
        ✗
              then
      
                (subs1,entry::entrylst);
      
            case (_,_,_)
      
              algorithm
      
        ✗
                true := Flags.isSet(Flags.FAILTRACE);
      
        ✗
                Debug.trace("- BackendDAE.getArrayEquationSub failed\n");
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end getArrayEquationSub;
      
        public function containAnyVar "author: PA
      
          Returns true if any of the variables given
      
          as ComponentRef list is among the BackendDAE.Variables."
      
          input list<DAE.ComponentRef> inExpComponentRefLst;
      
          input BackendDAE.Variables inVariables;
      
          output Boolean outBoolean;
      
        algorithm
      
          outBoolean := matchcontinue (inExpComponentRefLst,inVariables)
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.ComponentRef> crefs;
      
              BackendDAE.Variables vars;
      
            case ({},_) then false;
      
            case ((cr::_),vars)
      
              algorithm
      
        125111
                BackendVariable.getVar(cr, vars);
      
              then
      
                true;
      
            case ((_::crefs),vars)
      
        84913
              then
      
               containAnyVar(crefs, vars);
      
          end matchcontinue;
      
        end containAnyVar;
      
        protected function containAnyVarWithoutStates
      
        "Like containAnyVar but if var is state it is not counted."
      
          input list<DAE.ComponentRef> inExpComponentRefLst;
      
          input BackendDAE.Variables inVariables;
      
          output Boolean outBoolean;
      
        algorithm
      
          outBoolean := matchcontinue (inExpComponentRefLst,inVariables)
      
            local
      
              DAE.ComponentRef cr;
      
              list<DAE.ComponentRef> crefs;
      
              BackendDAE.Variables vars;
      
              BackendDAE.Var v;
      
            case ({},_) then false;
      
            case ((cr::_),vars)
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.

        1868
                (v::_,_) := BackendVariable.getVar(cr, vars);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.

        36
                false := BackendVariable.isStateVar(v);
      
              then
      
                true;
      
            case ((_::crefs),vars)
      
        1832
              then
      
               containAnyVarWithoutStates(crefs, vars);
      
          end matchcontinue;
      
        end containAnyVarWithoutStates;
      
        public function getEqnSysRhs "author: Frenkel TUD 2013-02
      
          Retrieve the right hand side of an equation system, given a set of variables.
      
          Uses A1*x + b1= A2*x + b2 -> 0 = (A1 - A2)*x+(b1-b2) -> x=0 -> rhs= A*0+b=b.
      
          Does not work for nonlinear Equations.
      
          inputs:  (DAE.Exp, BackendDAE.Variables /* variables of the eqn sys. */)
      
          outputs:  DAE.Exp =
      
        "
      
          input BackendDAE.EquationArray inEqns;
      
          input BackendDAE.Variables inVariables;
      
          input Option<AvlTreePathFunction.Tree> funcs;
      
          output list<DAE.Exp> outRhsExps;
      
          output list<DAE.ElementSource> outSources;
      
        protected
      
          BackendVarTransform.VariableReplacements repl;
      
        algorithm
      
        213
          repl := makeZeroReplacements(inVariables);
      
          2/2✓ Branch 2 taken 151 times.
✓ Branch 3 taken 62 times.

        213
          (_, outRhsExps, outSources, _, _) := BackendEquation.traverseEquationArray(inEqns, equationToExp, (inVariables, {}, {}, funcs, repl));
      
        end getEqnSysRhs;
      
        protected function equationToExp
      
          input BackendDAE.Equation inEq;
      
          input tuple<BackendDAE.Variables,list<DAE.Exp>,list<DAE.ElementSource>,Option<AvlTreePathFunction.Tree>,BackendVarTransform.VariableReplacements> inTpl;
      
          output BackendDAE.Equation outEq;
      
          output tuple<BackendDAE.Variables,list<DAE.Exp>,list<DAE.ElementSource>,Option<AvlTreePathFunction.Tree>,BackendVarTransform.VariableReplacements> outTpl;
      
        algorithm
      
          (outEq,outTpl) := matchcontinue (inEq,inTpl)
      
            local
      
              DAE.Exp e;
      
              DAE.Exp e1,e2,new_exp,rhs_exp,rhs_exp_1,rhs_exp_2;
      
              list<Integer> ds;
      
              BackendDAE.Equation eqn;
      
              BackendDAE.Variables v;
      
              list<DAE.Exp> explst,explst1;
      
              list<DAE.ElementSource> sources;
      
              DAE.ElementSource source;
      
              String str;
      
              list<list<DAE.Subscript>> subslst;
      
              Option<AvlTreePathFunction.Tree> funcs;
      
              BackendVarTransform.VariableReplacements repl;
      
              DAE.ComponentRef componentRef;
      
            case (eqn as BackendDAE.RESIDUAL_EQUATION(exp=e,source=source),(v,explst,sources,funcs,repl))
      
              algorithm
      
        ✗
                rhs_exp := getEqnsysRhsExp(e, v, funcs, SOME(repl));
      
        ✗
              then (eqn,(v,rhs_exp::explst,source::sources,funcs,repl));
      
            case (eqn as BackendDAE.EQUATION(exp=e1, scalar=e2,source=source),(v,explst,sources,funcs,repl))
      
              algorithm
      
        3438
                new_exp := Expression.expSub(e1,e2);
      
        3438
                rhs_exp := getEqnsysRhsExp(new_exp, v, funcs, SOME(repl));
      
        3438
                rhs_exp_1 := Expression.negate(rhs_exp);
      
        3438
                (rhs_exp_2,_) := ExpressionSimplify.simplify(rhs_exp_1);
      
        3438
              then (eqn,(v,rhs_exp_2::explst,source::sources,funcs,repl));
      
            case (eqn as BackendDAE.ARRAY_EQUATION(dimSize=ds, left=e1, right=e2, source=source), (v,explst,sources,funcs,repl))
      
              algorithm
      
        ✗
                new_exp := Expression.expSub(e1,e2);
      
        ✗
                subslst := Expression.dimensionSizesSubscripts(ds);
      
        ✗
                subslst := Expression.rangesToSubscripts(subslst);
      
        ✗
                explst1 := List.map1r(subslst,Expression.applyExpSubscripts,new_exp);
      
        ✗
                explst1 := List.map3(explst1,getEqnsysRhsExp,v,funcs,SOME(repl));
      
        ✗
                explst1 := List.map(explst1,Expression.negate);
      
        ✗
                explst1 := ExpressionSimplify.simplifyList(explst1);
      
        ✗
                explst := List.append_reverse(explst1,explst);
      
        ✗
                sources := List.consN(BackendEquation.equationSize(eqn), source, sources);
      
        ✗
              then (eqn,(v,explst,sources,funcs,repl));
      
            case (eqn as BackendDAE.SOLVED_EQUATION(componentRef=componentRef, exp=e2, source=source),(v,explst,sources,funcs,repl))
      
              algorithm
      
        ✗
                e1 := Expression.crefExp(componentRef);
      
        ✗
                new_exp := Expression.expSub(e1,e2);
      
        ✗
                rhs_exp := getEqnsysRhsExp(new_exp, v, funcs, SOME(repl));
      
        ✗
                rhs_exp_1 := Expression.negate(rhs_exp);
      
        ✗
                (rhs_exp_2,_) := ExpressionSimplify.simplify(rhs_exp_1);
      
        ✗
              then (eqn,(v,rhs_exp_2::explst,source::sources,funcs,repl));
      
            case (eqn as BackendDAE.COMPLEX_EQUATION(),_)
      
              algorithm
      
        ✗
                str := BackendDump.equationString(eqn);
      
        ✗
                str := "BackendDAEUtil.equationToExp failed for complex equation: " + str;
      
        ✗
                Error.addSourceMessage(Error.INTERNAL_ERROR,{str},BackendEquation.equationInfo(eqn));
      
        ✗
              then fail();
      
            case (eqn,_)
      
              algorithm
      
        ✗
                str := BackendDump.equationString(eqn);
      
        ✗
                str := "BackendDAEUtil.equationToExp failed: " + str;
      
        ✗
                Error.addSourceMessage(Error.INTERNAL_ERROR,{str},BackendEquation.equationInfo(eqn));
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end equationToExp;
      
        public function getEqnsysRhsExp "author: PA
      
          Retrieve the right hand side expression of an equation
      
          in an equation system, given a set of variables.
      
          Uses A1*x + b1= A2*x + b2 -> 0 = (A1 - A2)*x+(b1-b2) -> x=0 -> rhs= A*0+b=b.
      
          Does not work for nonlinear Equations.
      
          inputs:  (DAE.Exp, BackendDAE.Variables /* variables of the eqn sys. */)
      
          outputs:  DAE.Exp =
      
        "
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inVariables;
      
          input Option<AvlTreePathFunction.Tree> funcs;
      
          input Option<BackendVarTransform.VariableReplacements> oRepl;
      
          output DAE.Exp outExp;
      
        algorithm
      
          outExp := match oRepl
      
            local
      
              BackendVarTransform.VariableReplacements repl;
      
            case SOME(repl)
      
              algorithm
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 3777 times.

        3777
               (outExp,(_,_,_,true)) := Expression.traverseExpTopDown(inExp, getEqnsysRhsExp1, (repl,inVariables,funcs,true));
      
        3777
               (outExp,_) := ExpressionSimplify.simplify(outExp);
      
              then
      
                outExp;
      
            else
      
              algorithm
      
        ✗
                repl := makeZeroReplacements(inVariables);
      
        ✗
               (outExp,(_,_,_,true)) := Expression.traverseExpTopDown(inExp, getEqnsysRhsExp1, (repl,inVariables,funcs,true));
      
        ✗
               (outExp,_) := ExpressionSimplify.simplify(outExp);
      
              then
      
                outExp;
      
          end match;
      
        end getEqnsysRhsExp;
      
        protected function getEqnsysRhsExp1
      
          input DAE.Exp inExp;
      
          input tuple<BackendVarTransform.VariableReplacements,BackendDAE.Variables,Option<AvlTreePathFunction.Tree>,Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendVarTransform.VariableReplacements,BackendDAE.Variables,Option<AvlTreePathFunction.Tree>,Boolean> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := match (inExp,inTpl)
      
            local
      
              DAE.Exp cond,t,f,e, e1, e2, zero,exp;
      
              DAE.Type tp;
      
              BackendVarTransform.VariableReplacements repl;
      
              BackendDAE.Variables vars;
      
              Boolean b,b1;
      
              Absyn.Path path;
      
              list<DAE.Exp> expLst;
      
              Option<AvlTreePathFunction.Tree> funcs;
      
              tuple<BackendVarTransform.VariableReplacements,BackendDAE.Variables,Option<AvlTreePathFunction.Tree>,Boolean> tpl;
      
            case (e as DAE.CREF(),(repl,_,_,_))
      
              algorithm
      
        26257
                (e1,b1) := BackendVarTransform.replaceExp(e, repl, NONE());
      
          2/2✓ Branch 0 taken 13511 times.
✓ Branch 1 taken 12746 times.

        26257
                e1 := if b1 then e1 else e;
      
              then (e1,false,inTpl);
      
            case (DAE.IFEXP(cond,t,f),(repl,vars,funcs,b))
      
              algorithm
      
                // check if vars not in condition
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 176 times.

        176
                (_,(_,b)) := Expression.traverseExpTopDown(cond, getEqnsysRhsExp2, (vars,b));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 176 times.

        176
                (t,tpl) := Expression.traverseExpTopDown(t, getEqnsysRhsExp1, (repl,vars,funcs,b));
      
        176
                (f,tpl) := Expression.traverseExpTopDown(f, getEqnsysRhsExp1, tpl);
      
        176
              then
      
                (DAE.IFEXP(cond,t,f),false,tpl);
      
            case (e as DAE.CALL(path=Absyn.IDENT(name = "der")),_)
      
              then (e,true,inTpl);
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "pre")),_)
      
              then (e,false,inTpl);
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "previous")),_)
      
              then (e,false,inTpl);
      
            case (e as DAE.CALL(path = Absyn.IDENT(name = "semiLinear"), expLst={cond,t,f}),_)
      
               algorithm
      
        ✗
                tp := Expression.typeof(e);
      
        ✗
                (zero, _) := Expression.makeZeroExpression(Expression.arrayDimension(tp));
      
        ✗
                e1 := Expression.expMul(cond,t);
      
        ✗
                e2 := Expression.expMul(cond,f);
      
        ✗
                exp := DAE.IFEXP(DAE.RELATION(cond, DAE.GREATEREQ(tp), zero, -1, NONE()), e1, e2);
      
        ✗
                (exp, tpl) := Expression.traverseExpTopDown(exp, getEqnsysRhsExp1, inTpl);
      
        ✗
              then (exp,false,tpl);
      
            case (e as DAE.CALL(expLst=expLst),(repl,vars,funcs,b))
      
              algorithm
      
                // check if vars not in expList
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

        9
                (_,(_,b)) := Expression.traverseExpListTopDown(expLst, getEqnsysRhsExp2, (vars,b));
      
        9
                (e,b) := getEqnsysRhsExp3(b,e,(repl,vars,funcs,true));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

        9
              then (e,false,(repl,vars,funcs,b));
      
            case (e,(_,_,_,b)) then (e,b,inTpl);
      
          end match;
      
        end getEqnsysRhsExp1;
      
        protected function getEqnsysRhsExp3
      
          input Boolean b;
      
          input DAE.Exp inExp;
      
          input tuple<BackendVarTransform.VariableReplacements,BackendDAE.Variables,Option<AvlTreePathFunction.Tree>,Boolean> iTpl;
      
          output DAE.Exp oExp;
      
          output Boolean notfound;
      
        algorithm
      
          (oExp,notfound) := matchcontinue(b, iTpl)
      
          local
      
            Option<AvlTreePathFunction.Tree> funcs;
      
            DAE.Exp e;
      
          case (false, (_,_,funcs,_))
      
            algorithm
      
              // try to inline
      
        ✗
              (e,_,true) := Inline.forceInlineExp(inExp,(funcs,{DAE.NORM_INLINE(),DAE.DEFAULT_INLINE()}),DAE.emptyElementSource,Ceval.cevalSimpleWithFunctionTreeReturnExp);
      
        ✗
              (e,(_,_,_,notfound)) := Expression.traverseExpTopDown(e, getEqnsysRhsExp1, iTpl);
      
            then
      
              (e,notfound);
      
          else (inExp,b);
      
          end matchcontinue;
      
        end getEqnsysRhsExp3;
      
        public function getEqnsysRhsExp2
      
          input DAE.Exp inExp;
      
          input tuple<BackendDAE.Variables,Boolean> inTpl;
      
          output DAE.Exp outExp;
      
          output Boolean cont;
      
          output tuple<BackendDAE.Variables,Boolean> outTpl;
      
        algorithm
      
          (outExp,cont,outTpl) := matchcontinue (inExp,inTpl)
      
            local
      
              BackendDAE.Variables vars;
      
              DAE.ComponentRef cr;
      
              Boolean b;
      
            // special case for time, it is never part of the equation system
      
            case (DAE.CREF(componentRef = DAE.CREF_IDENT(ident="time")),_)
      
              then (inExp, false, inTpl);
      
            // case for functionpointers
      
            case (DAE.CREF(ty=DAE.T_FUNCTION_REFERENCE_FUNC()),_)
      
              then (inExp, false, inTpl);
      
            case (DAE.CALL(path = Absyn.IDENT(name = "pre")),_)
      
              then (inExp,false,inTpl);
      
            case (DAE.CALL(path = Absyn.IDENT(name = "previous")),_)
      
              then (inExp,false,inTpl);
      
            // found ?
      
            case (DAE.CREF(componentRef = cr),(vars,_))
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.

        3374
                 (_::_,_) := BackendVariable.getVar(cr, vars);
      
        21
              then (inExp, false,(vars,false));
      
            case (_,(_,b)) then (inExp,b,inTpl);
      
          end matchcontinue;
      
        end getEqnsysRhsExp2;
      
        public function makeZeroReplacements "
      
          Help function to ifBranchesFreeFromVar, creates replacement rules
      
          v -> 0, for all variables"
      
          input BackendDAE.Variables vars;
      
          output BackendVarTransform.VariableReplacements repl;
      
        algorithm
      
        475
          repl := BackendVariable.traverseBackendDAEVars(vars,makeZeroReplacement,BackendVarTransform.emptyReplacements());
      
        end makeZeroReplacements;
      
        protected function makeZeroReplacement "helper function to makeZeroReplacements.
      
        Creates replacement BackendDAE.Var -> 0"
      
          input BackendDAE.Var inVar;
      
          input BackendVarTransform.VariableReplacements inRepl;
      
          output BackendDAE.Var var;
      
          output BackendVarTransform.VariableReplacements repl;
      
        algorithm
      
          (var,repl) := matchcontinue (inVar,inRepl)
      
            local
      
              DAE.ComponentRef cr;
      
            case (var,repl)
      
              algorithm
      
        4516
                cr :=  BackendVariable.varCref(var);
      
        4516
                repl := BackendVarTransform.addReplacement(repl,cr,Expression.makeConstZero(ComponentReference.crefLastType(cr)),NONE());
      
              then (var,repl);
      
            else (inVar,inRepl);
      
          end matchcontinue;
      
        end makeZeroReplacement;
      
        /*************************************************
      
         * traverseBackendDAE and stuff
      
         ************************************************/
      
        public function traverseBackendDAEExps "author: Frenkel TUD
      
          This function goes through the BackendDAE structure and finds all the
      
          expressions and performs the function on them in a list
      
          an extra argument passed through the function.
      
        "
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA := matchcontinue inBackendDAE
      
            local
      
              BackendDAE.Shared shared;
      
              list<BackendDAE.EqSystem> systs;
      
              String name;
      
            case BackendDAE.DAE(systs, shared)
      
              algorithm
      
        7547
                outTypeA := List.fold1(systs, traverseBackendDAEExpsEqSystem, func, inTypeA);
      
        7547
                outTypeA := traverseBackendDAEExpsVars(shared.globalKnownVars, func, outTypeA);
      
        7547
                outTypeA := traverseBackendDAEExpsEqns(shared.initialEqs, func, outTypeA);
      
        7547
                outTypeA := traverseBackendDAEExpsEqns(shared.removedEqs, func, outTypeA);
      
              then
      
                outTypeA;
      
            else algorithm
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Error.addInternalError("traverseBackendDAEExps failed for " + name, sourceInfo());
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end traverseBackendDAEExps;
      
        public function traverseBackendDAEExpsEqSystemJacobians "author: wbraun
      
          This function goes through the all jacobians and stateSets and finds all the
      
          expressions and performs the function on them in a list
      
          an extra argument passed through the function.
      
        "
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.EqSystem syst;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA :=
      
          matchcontinue syst
      
            local
      
              BackendDAE.StrongComponents comps;
      
              BackendDAE.StateSets stateSets;
      
              Type_a arg;
      
            case BackendDAE.EQSYSTEM(stateSets = stateSets)
      
              algorithm
      
        50745
                comps := getStrongComponents(syst);
      
        50745
                arg := traverseStrongComponentsJacobiansExp(comps, func, inTypeA);
      
        50745
                arg := traverseStateSetsJacobiansExp(stateSets, func, arg);
      
             then arg;
      
            else inTypeA;
      
          end matchcontinue;
      
        end traverseBackendDAEExpsEqSystemJacobians;
      
        public function traverseStrongComponentsJacobiansExp
      
         "author: wbraun"
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.StrongComponents inComps;
      
          input FuncExpType inFunc;
      
          input output Type_a arg;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          2/2✓ Branch 0 taken 134977 times.
✓ Branch 1 taken 50745 times.

        185722
          for comp in inComps loop
      
            arg := match comp
      
              local
      
                list<tuple<Integer, Integer, BackendDAE.Equation>> jac;
      
                BackendDAE.BackendDAE bdae;
      
              case BackendDAE.EQUATIONSYSTEM(jac=BackendDAE.FULL_JACOBIAN(SOME(jac)))
      
        143
                then traverseBackendDAEExpsJacobianEqn(jac, inFunc, arg);
      
              case BackendDAE.EQUATIONSYSTEM(jac=BackendDAE.GENERIC_JACOBIAN(jacobian = SOME((bdae,_,_,_,_,_))))
      
        255
                then traverseBackendDAEExps(bdae, inFunc, arg);
      
              case BackendDAE.TORNSYSTEM(BackendDAE.TEARINGSET(jac=BackendDAE.GENERIC_JACOBIAN(jacobian = SOME((bdae,_,_,_,_,_)))))
      
        1176
                then traverseBackendDAEExps(bdae, inFunc, arg);
      
              else arg;
      
            end match;
      
          end for;
      
        end traverseStrongComponentsJacobiansExp;
      
        protected function traverseBackendDAEExpsJacobianEqn "Helper for traverseExpsOfEquation."
      
          replaceable type Type_a subtypeof Any;
      
          input list<tuple<Integer, Integer, BackendDAE.Equation>> inJacEntry;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA :=
      
            match inJacEntry
      
             local
      
              BackendDAE.Equation eqn;
      
              Type_a typeA;
      
            case {} then inTypeA;
      
            case (_,_,eqn)::_
      
              algorithm
      
        143
               typeA := traverseBackendDAEExpsOptEqn(SOME(eqn),func,inTypeA);
      
             then typeA;
      
          end match;
      
        end traverseBackendDAEExpsJacobianEqn;
      
        public function traverseStateSetsJacobiansExp
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.StateSets inStateSets;
      
          input FuncExpType inFunc;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA :=
      
          match inStateSets
      
            local
      
              BackendDAE.StateSets rest;
      
              BackendDAE.BackendDAE bdae;
      
              Type_a arg;
      
            case {} then inTypeA;
      
            case BackendDAE.STATESET(jacobian = BackendDAE.GENERIC_JACOBIAN(jacobian = SOME((bdae,_,_,_,_,_))))::rest
      
              algorithm
      
        21
                arg := traverseBackendDAEExps(bdae, inFunc, inTypeA);
      
        21
              then
      
                traverseStateSetsJacobiansExp(rest, inFunc, arg);
      
          end match;
      
        end traverseStateSetsJacobiansExp;
      
        public function traverseBackendDAEExpsNoCopyWithUpdate<A>
      
         "This function goes through the BackendDAE structure and finds all the
      
          expressions and performs the function on them in a list
      
          an extra argument passed through the function."
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          input FuncExpType func;
      
          input A inTypeA;
      
          output A outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input A inTypeA;
      
            output DAE.Exp outExp;
      
            output A outA;
      
          end FuncExpType;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
          String name;
      
        algorithm
      
          try
      
        2378
            BackendDAE.DAE(systs, shared) := inBackendDAE;
      
        2378
            outTypeA := List.fold1(systs, traverseBackendDAEExpsEqSystemWithUpdate, func, inTypeA);
      
        2378
            outTypeA := traverseBackendDAEExpsVarsWithUpdate(shared.globalKnownVars, func, outTypeA);
      
        2378
            outTypeA := traverseBackendDAEExpsEqns(shared.initialEqs, func, outTypeA);
      
        2378
            outTypeA := traverseBackendDAEExpsEqns(shared.removedEqs, func, outTypeA);
      
          else
      
        ✗
            (_, _, name) := System.dladdr(func);
      
        ✗
            Error.addInternalError("traverseBackendDAEExpsNoCopyWithUpdate failed for " + name, sourceInfo());
      
        ✗
            fail();
      
          end try;
      
        end traverseBackendDAEExpsNoCopyWithUpdate;
      
        public function traverseBackendDAEExpsEqSystem "This function goes through the BackendDAE structure and finds all the
      
          expressions and performs the function on them in a list
      
          an extra argument passed through the function.
      
        "
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.EqSystem syst;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
        81907
          outTypeA := traverseBackendDAEExpsVars(syst.orderedVars, func, inTypeA);
      
        81907
          outTypeA := traverseBackendDAEExpsEqns(syst.orderedEqs, func, outTypeA);
      
        81907
          outTypeA := traverseBackendDAEExpsEqns(syst.removedEqs, func, outTypeA);
      
        end traverseBackendDAEExpsEqSystem;
      
        public function traverseBackendDAEExpsEqSystemWithUpdate "This function goes through the BackendDAE structure and finds all the
      
          expressions and performs the function on them in a list
      
          an extra argument passed through the function."
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.EqSystem syst;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
        55022
          outTypeA := traverseBackendDAEExpsVarsWithUpdate(syst.orderedVars, func, inTypeA);
      
        55022
          outTypeA := traverseBackendDAEExpsEqns(syst.orderedEqs, func, outTypeA);
      
        55022
          outTypeA := traverseBackendDAEExpsEqns(syst.removedEqs, func, outTypeA);
      
        end traverseBackendDAEExpsEqSystemWithUpdate;
      
        public function traverseBackendDAEExpsVars "Helper for traverseBackendDAEExps"
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.Variables inVariables;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA:=
      
          matchcontinue inVariables
      
            local
      
              array<Option<BackendDAE.Var>> varOptArr;
      
              Type_a ext_arg_1;
      
              String name;
      
            case BackendDAE.VARIABLES(varArr = BackendDAE.VARIABLE_ARRAY(varOptArr=varOptArr))
      
              algorithm
      
        96961
                ext_arg_1 := traverseArrayNoCopy(varOptArr,func,traverseBackendDAEExpsVar,inTypeA);
      
              then
      
                ext_arg_1;
      
            else algorithm
      
        ✗
              true := Flags.isSet(Flags.FAILTRACE);
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Debug.trace("- BackendDAE.traverseBackendDAEExpsVars failed for " + name + "\n");
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end traverseBackendDAEExpsVars;
      
        public function traverseBackendDAEExpsVarsWithUpdate "Helper for traverseBackendDAEExps"
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.Variables inVariables;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          outTypeA:=
      
          matchcontinue inVariables
      
            local
      
              array<Option<BackendDAE.Var>> varOptArr;
      
              Type_a ext_arg_1;
      
              String name;
      
            case BackendDAE.VARIABLES(varArr = BackendDAE.VARIABLE_ARRAY(varOptArr=varOptArr))
      
              algorithm
      
        60224
                (_,ext_arg_1) := traverseArrayNoCopyWithUpdate(varOptArr,func,traverseBackendDAEExpsVarWithUpdate,inTypeA);
      
        60224
              then
      
                ext_arg_1;
      
            else algorithm
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Error.addInternalError("traverseBackendDAEExpsVarsWithUpdate failed for " + name, sourceInfo());
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end traverseBackendDAEExpsVarsWithUpdate;
      
        public function traverseArrayNoCopy<ArrT, ElemT, ArgT>
      
          input array<ArrT> inArray;
      
          input ElemFuncType inElemFunc;
      
          input ArrayFuncType inArrayFunc;
      
          input ArgT inArg;
      
          input Integer inLength = arrayLength(inArray);
      
          output ArgT outArg = inArg;
      
          partial function ElemFuncType
      
            input ElemT inElement;
      
            input ArgT inArg;
      
            output ElemT outElement;
      
            output ArgT outArg;
      
          end ElemFuncType;
      
          partial function ArrayFuncType
      
            input ArrT inElement;
      
            input ElemFuncType inFunc;
      
            input ArgT inArg;
      
            output ArgT outArg;
      
          end ArrayFuncType;
      
        algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 426472 times.

        426472
          true := inLength <= arrayLength(inArray);
      
          2/2✓ Branch 0 taken 25094 times.
✓ Branch 1 taken 401378 times.

        61150450
          for i in 1:inLength loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60723978 times.

        60723978
            outArg := inArrayFunc(inArray[i], inElemFunc, outArg);
      
          end for;
      
        end traverseArrayNoCopy;
      
        public function traverseArrayNoCopyWithStop<ArrT, ElemT, ArgT>
      
          "Same as traverseArrayNoCopy, but with an additional parameter to
      
           stop the traversal."
      
          input array<ArrT> inArray;
      
          input ElemFuncType inElemFunc;
      
          input ArrayFuncType inArrayFunc;
      
          input ArgT inArg;
      
          input Integer inLength = arrayLength(inArray);
      
          output ArgT outArg = inArg;
      
          partial function ElemFuncType
      
            input ElemT inElement;
      
            input ArgT inArg;
      
            output ElemT outElement;
      
            output Boolean outContinue;
      
            output ArgT outArg;
      
          end ElemFuncType;
      
          partial function ArrayFuncType
      
            input ArrT inElement;
      
            input ElemFuncType inFunc;
      
            input ArgT inArg;
      
            output Boolean outContinue;
      
            output ArgT outArg;
      
          end ArrayFuncType;
      
        protected
      
          Boolean cont;
      
        algorithm
      
        ✗
          true := inLength <= arrayLength(inArray);
      
        ✗
          for i in 1:inLength loop
      
        ✗
            (cont, outArg) := inArrayFunc(inArray[i], inElemFunc, outArg);
      
        ✗
            if not cont then break; end if;
      
          end for;
      
        end traverseArrayNoCopyWithStop;
      
        public function traverseArrayNoCopyWithUpdate<ArrT, ElemT, ArgT>
      
          input array<ArrT> inArray;
      
          input ElemFuncType inElemFunc;
      
          input ArrayFuncType inArrayFunc;
      
          input ArgT inArg;
      
          input Integer inLength = arrayLength(inArray);
      
          output array<ArrT> outArray = inArray;
      
          output ArgT outArg = inArg;
      
          partial function ElemFuncType
      
            input ElemT inElement;
      
            input ArgT inArg;
      
            output ElemT outElement;
      
            output ArgT outArg;
      
          end ElemFuncType;
      
          partial function ArrayFuncType
      
            input ArrT inElement;
      
            input ElemFuncType inFunc;
      
            input ArgT inArg;
      
            output ArrT outElement;
      
            output ArgT outArg;
      
          end ArrayFuncType;
      
        protected
      
          ArrT e, new_e;
      
        algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 98543 times.

        98543
          true := inLength <= arrayLength(inArray);
      
          2/2✓ Branch 0 taken 7073 times.
✓ Branch 1 taken 91470 times.

        22553673
          for i in 1:inLength loop
      
        22455130
            e := inArray[i];
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22455130 times.

        22455130
            (new_e, outArg) := inArrayFunc(e, inElemFunc, outArg);
      
          2/2✓ Branch 0 taken 18336607 times.
✓ Branch 1 taken 4118523 times.

        22455130
            if not referenceEq(e, new_e) then
      
        18336607
              arrayUpdate(outArray, i, new_e);
      
            end if;
      
          end for;
      
        end traverseArrayNoCopyWithUpdate;
      
        protected function traverseBackendDAEExpsVar "author: Frenkel TUD
      
          Helper traverseBackendDAEExpsVar. Get all exps from a BackendDAE.Var.
      
          DAE.T_UNKNOWN_DEFAULT is used as type for componentref. Not important here.
      
          We only use the exp list for finding function calls"
      
          replaceable type Type_a subtypeof Any;
      
          input Option<BackendDAE.Var> inVar;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
        55832953
          (_,outTypeA):=traverseBackendDAEExpsVarWithUpdate(inVar,func,inTypeA);
      
        end traverseBackendDAEExpsVar;
      
        protected function traverseBackendDAEExpsVarWithUpdate "author: Frenkel TUD
      
          Helper traverseBackendDAEExpsVar. Get all exps from a BackendDAE.Var.
      
          DAE.T_UNKNOWN_DEFAULT is used as type for componentref. Not important here.
      
          We only use the exp list for finding function calls"
      
          replaceable type Type_a subtypeof Any;
      
          input Option<BackendDAE.Var> inVar;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Option<BackendDAE.Var> ovar;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          (ovar, outTypeA) := matchcontinue inVar
      
            local
      
              DAE.Exp e1, e1_;
      
              DAE.ComponentRef cref;
      
              list<DAE.Dimension> instdims;
      
              Option<DAE.VariableAttributes> attr, attr_;
      
              Option<BackendDAE.TearingSelect> ts;
      
              Option<DAE.Exp> hideResult;
      
              Type_a ext_arg_1, ext_arg_2;
      
              BackendDAE.VarKind varKind;
      
              DAE.VarDirection varDirection;
      
              DAE.VarParallelism varParallelism;
      
              BackendDAE.Type varType;
      
              DAE.ElementSource source;
      
              Option<SCode.Comment> comment;
      
              DAE.ConnectorType ct;
      
              DAE.VarInnerOuter io;
      
              Boolean unreplaceable, initNonlinear, encrypted;
      
              String name;
      
              Option<BackendDAE.Var> v;
      
              Option<DAE.Exp> tplExp;
      
            case NONE()
      
            then (NONE(), inTypeA);
      
            case SOME(BackendDAE.VAR(cref, varKind, varDirection, varParallelism, varType, SOME(e1), tplExp, instdims, source, attr, ts, hideResult, comment, ct, io, unreplaceable, initNonlinear, encrypted)) algorithm
      
          2/2✓ Branch 0 taken 369973 times.
✓ Branch 1 taken 1437076 times.

        1807049
              (e1_, ext_arg_1) := func(e1, inTypeA);
      
        1807049
              (attr_, ext_arg_2) := traverseBackendDAEVarAttr(attr, func, ext_arg_1);
      
          2/2✓ Branch 0 taken 65418 times.
✓ Branch 1 taken 1741631 times.

        1807049
              if referenceEq(e1,e1_) and referenceEq(attr,attr_) then
      
                v := inVar;
      
              else
      
          4/6✓ Branch 0 taken 65418 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65418 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 62186 times.
✓ Branch 5 taken 3232 times.

        261672
                v := SOME(BackendDAE.VAR(cref, varKind, varDirection, varParallelism, varType, SOME(e1_), tplExp, instdims, source, attr_, ts, hideResult, comment, ct, io, unreplaceable, initNonlinear, encrypted));
      
              end if;
      
        1807049
            then (v, ext_arg_2);
      
            case SOME(BackendDAE.VAR(cref, varKind, varDirection, varParallelism, varType, NONE(), tplExp, instdims, source, attr, ts, hideResult, comment, ct, io, unreplaceable, initNonlinear, encrypted)) algorithm
      
        838541
              (attr_, ext_arg_2) := traverseBackendDAEVarAttr(attr, func, inTypeA);
      
          2/2✓ Branch 0 taken 316886 times.
✓ Branch 1 taken 521655 times.

        838541
              if referenceEq(attr,attr_) then
      
                v := inVar;
      
              else
      
          4/6✓ Branch 0 taken 316886 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 316886 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 297130 times.
✓ Branch 5 taken 19756 times.

        1247788
                v := SOME(BackendDAE.VAR(cref, varKind, varDirection, varParallelism, varType, NONE(), tplExp, instdims, source, attr_, ts, hideResult, comment, ct, io, unreplaceable, initNonlinear, encrypted));
      
              end if;
      
        838541
            then (v, ext_arg_2);
      
            else algorithm
      
        ✗
              true := Flags.isSet(Flags.FAILTRACE);
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Debug.trace("- BackendDAE.traverseBackendDAEExpsVar failed for " + name + "\n");
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end traverseBackendDAEExpsVarWithUpdate;
      
        public function traverseBackendDAEVarAttr
      
        "help function to traverseBackendDAEExpsVarWithUpdate
      
        author: Peter Aronsson (paronsson@wolfram.com)
      
        "
      
          input Option<DAE.VariableAttributes> attr;
      
          input FuncExpType func;
      
          input ExtraArgType extraArg;
      
          replaceable type ExtraArgType subtypeof Any;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input ExtraArgType inTypeA;
      
            output DAE.Exp outExp;
      
            output ExtraArgType outA;
      
          end FuncExpType;
      
          output Option<DAE.VariableAttributes> outAttr;
      
          output ExtraArgType outExtraArg;
      
        algorithm
      
         (outAttr,outExtraArg) := match attr
      
           local
      
             Option<DAE.Exp> q,u,du,min,max,i,f,n,eqbound;
      
             Option<DAE.StartOrigin> startOrigin;
      
             Option<DAE.Exp> q_,u_,du_,min_,max_,i_,f_,n_,eqbound_;
      
             Option<DAE.StateSelect> ss;
      
             Option<DAE.Uncertainty> unc;
      
             Option<DAE.Distribution> dist, dist_;
      
             Option<Boolean> p,fin;
      
             Option<DAE.VariableAttributes> a;
      
           case NONE() then (NONE(),extraArg);
      
           case SOME(DAE.VAR_ATTR_REAL(q,u,du,min,max,i,f,n,ss,unc,dist,eqbound,p,fin,startOrigin)) algorithm
      
        3217341
             (q_,outExtraArg) := Expression.traverseExpOpt(q,func,extraArg);
      
        3217341
             (u_,outExtraArg) := Expression.traverseExpOpt(u,func,outExtraArg);
      
        3217341
             (du_,outExtraArg) := Expression.traverseExpOpt(du,func,outExtraArg);
      
        3217341
             (min_,outExtraArg) := Expression.traverseExpOpt(min,func,outExtraArg);
      
        3217341
             (max_,outExtraArg) := Expression.traverseExpOpt(max,func,outExtraArg);
      
        3217341
             (i_,outExtraArg) := Expression.traverseExpOpt(i,func,outExtraArg);
      
        3217341
             (f_,outExtraArg) := Expression.traverseExpOpt(f,func,outExtraArg);
      
        3217341
             (n_,outExtraArg) := Expression.traverseExpOpt(n,func,outExtraArg);
      
        3217341
             (eqbound_,outExtraArg) := Expression.traverseExpOpt(eqbound,func,outExtraArg);
      
        3217341
             (dist_,outExtraArg) := traverseBackendDAEAttrDistribution(dist,func,outExtraArg);
      
          9/10✓ Branch 0 taken 3217281 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 3217183 times.
✓ Branch 3 taken 98 times.
✓ Branch 4 taken 3213587 times.
✓ Branch 5 taken 3596 times.
✓ Branch 6 taken 3213587 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 846670 times.
✓ Branch 9 taken 2366917 times.

        3217341
             if referenceEq(q,q_) and referenceEq(u,u_) and referenceEq(du,du_) and referenceEq(min,min_) and referenceEq(max,max_) and referenceEq(i,i_) and referenceEq(f,f_) and referenceEq(n,n_)
      
                and referenceEq(eqbound,eqbound_) and referenceEq(dist,dist_) then
      
                a := attr;
      
              else
      
        850424
                a := SOME(DAE.VAR_ATTR_REAL(q_,u_,du_,min_,max_,i_,f_,n_,ss,unc,dist_,eqbound_,p,fin,startOrigin));
      
             end if;
      
        3217341
           then (a,outExtraArg);
      
           case SOME(DAE.VAR_ATTR_INT(q,min,max,i,f,unc,dist,eqbound,p,fin,startOrigin)) algorithm
      
        139110
             (q_,outExtraArg) := Expression.traverseExpOpt(q,func,extraArg);
      
        139110
             (min_,outExtraArg) := Expression.traverseExpOpt(min,func,outExtraArg);
      
        139110
             (max_,outExtraArg) := Expression.traverseExpOpt(max,func,outExtraArg);
      
        139110
             (i_,outExtraArg) := Expression.traverseExpOpt(i,func,outExtraArg);
      
        139110
             (f_,outExtraArg) := Expression.traverseExpOpt(f,func,outExtraArg);
      
        139110
             (eqbound_,outExtraArg) := Expression.traverseExpOpt(eqbound,func,outExtraArg);
      
        139110
             (dist_,outExtraArg) := traverseBackendDAEAttrDistribution(dist,func,outExtraArg);
      
          5/8✓ Branch 0 taken 139110 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 139110 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 139110 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 28140 times.
✓ Branch 7 taken 110970 times.

        139110
             if referenceEq(q,q_) and referenceEq(min,min_) and referenceEq(max,max_) and referenceEq(i,i_) and referenceEq(f,f_)
      
                and referenceEq(eqbound,eqbound_) and referenceEq(dist,dist_) then
      
                a := attr;
      
              else
      
        28140
                a := SOME(DAE.VAR_ATTR_INT(q_,min_,max_,i_,f_,unc,dist_,eqbound_,p,fin,startOrigin));
      
             end if;
      
        139110
           then (a,outExtraArg);
      
           case SOME(DAE.VAR_ATTR_BOOL(q,i,f,eqbound,p,fin,startOrigin)) algorithm
      
        147932
             (q_,outExtraArg) := Expression.traverseExpOpt(q,func,extraArg);
      
        147932
             (i_,outExtraArg) := Expression.traverseExpOpt(i,func,outExtraArg);
      
        147932
             (f_,outExtraArg) := Expression.traverseExpOpt(f,func,outExtraArg);
      
        147932
             (eqbound_,outExtraArg) := Expression.traverseExpOpt(eqbound,func,outExtraArg);
      
          2/4✓ Branch 0 taken 147932 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 147932 times.

        147932
             if referenceEq(q,q_) and referenceEq(i,i_) and referenceEq(f,f_) and referenceEq(eqbound,eqbound_) then
      
                a := attr;
      
              else
      
        ✗
                a := SOME(DAE.VAR_ATTR_BOOL(q_,i_,f_,eqbound_,p,fin,startOrigin));
      
             end if;
      
        147932
           then (a,outExtraArg);
      
           case SOME(DAE.VAR_ATTR_STRING(q,i,f,eqbound,p,fin,startOrigin)) algorithm
      
        15430
             (q_,outExtraArg) := Expression.traverseExpOpt(q,func,extraArg);
      
        15430
             (i_,outExtraArg) := Expression.traverseExpOpt(i,func,outExtraArg);
      
        15430
             (f_,outExtraArg) := Expression.traverseExpOpt(f,func,outExtraArg);
      
        15430
             (eqbound_,outExtraArg) := Expression.traverseExpOpt(eqbound,func,outExtraArg);
      
          2/4✓ Branch 0 taken 15430 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 15430 times.

        15430
             if referenceEq(q,q_) and referenceEq(i,i_) and referenceEq(f,f_) and referenceEq(eqbound,eqbound_) then
      
                a := attr;
      
              else
      
        ✗
                a := SOME(DAE.VAR_ATTR_STRING(q_,i_,f_,eqbound_,p,fin,startOrigin));
      
             end if;
      
        15430
           then (a,outExtraArg);
      
           case SOME(DAE.VAR_ATTR_ENUMERATION(q,min,max,i,f,eqbound,p,fin,startOrigin)) algorithm
      
        24068
             (q_,outExtraArg) := Expression.traverseExpOpt(q,func,extraArg);
      
        24068
             (min_,outExtraArg) := Expression.traverseExpOpt(min,func,outExtraArg);
      
        24068
             (max_,outExtraArg) := Expression.traverseExpOpt(max,func,outExtraArg);
      
        24068
             (i_,outExtraArg) := Expression.traverseExpOpt(i,func,outExtraArg);
      
        24068
             (f_,outExtraArg) := Expression.traverseExpOpt(f,func,outExtraArg);
      
        24068
             (eqbound_,outExtraArg) := Expression.traverseExpOpt(eqbound,func,outExtraArg);
      
          3/6✓ Branch 0 taken 24068 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 24068 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 24068 times.

        24068
             if referenceEq(q,q_) and referenceEq(min,min_) and referenceEq(max,max_) and referenceEq(i,i_) and referenceEq(f,f_) and referenceEq(eqbound,eqbound_) then
      
                a := attr;
      
              else
      
        ✗
                a := SOME(DAE.VAR_ATTR_ENUMERATION(q_,min_,max_,i_,f_,eqbound_,p,fin,startOrigin));
      
             end if;
      
        24068
            then (a,outExtraArg);
      
          case SOME(DAE.VAR_ATTR_CLOCK(_, _))
      
            then (attr,extraArg);
      
         end match;
      
        end traverseBackendDAEVarAttr;
      
        protected function traverseBackendDAEAttrDistribution
      
        "help function to traverseBackendDAEVarAttr
      
        author: Peter Aronsson (paronsson@wolfram.com)
      
        "
      
          input Option<DAE.Distribution> distOpt;
      
          input FuncExpType func;
      
          input Type_a extraArg;
      
          replaceable type Type_a subtypeof Any;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
          output Option<DAE.Distribution> outDistOpt;
      
          output Type_a outExtraArg;
      
        algorithm
      
         (outDistOpt,outExtraArg) := match(distOpt, extraArg)
      
         local
      
           DAE.Exp name,arr,sarr;
      
           DAE.Exp name_,arr_,sarr_;
      
           Option<DAE.Distribution> d;
      
           case(NONE(), outExtraArg) then (NONE(),outExtraArg);
      
           case(SOME(DAE.DISTRIBUTION(name,arr,sarr)), _) algorithm
      
        ✗
             (arr_,_) := Expression.extendArrExp(arr,false);
      
        ✗
             (sarr_,_) := Expression.extendArrExp(sarr,false);
      
        ✗
             (name_,outExtraArg) := Expression.traverseExpBottomUp(name,func,extraArg);
      
        ✗
             (arr_,outExtraArg) := Expression.traverseExpBottomUp(arr_,func,outExtraArg);
      
        ✗
             (sarr_,outExtraArg) := Expression.traverseExpBottomUp(sarr_,func,outExtraArg);
      
        ✗
             if referenceEq(name, name_) and referenceEq(arr, arr_) and referenceEq(sarr, sarr_) then
      
               d := distOpt;
      
             else
      
        ✗
               d := SOME(DAE.DISTRIBUTION(name_,arr_,sarr_));
      
             end if;
      
        ✗
            then (d,outExtraArg);
      
         end match;
      
        end traverseBackendDAEAttrDistribution;
      
        public function traverseBackendDAEExpsEqns<T> "author: lochel
      
          Traverse all expressions of an equation array and apply modifications to them."
      
          input BackendDAE.EquationArray equationArray;
      
          input FuncExpType func;
      
          input output T extraArg;
      
          partial function FuncExpType
      
            input output DAE.Exp exp;
      
            input output T extraArg;
      
          end FuncExpType;
      
        protected
      
          String name;
      
          BackendDAE.Equation eqn, eqn_new;
      
        algorithm
      
          try
      
          2/2✓ Branch 1 taken 192057 times.
✓ Branch 2 taken 201526 times.

        2057314
            for i in 1:ExpandableArray.getLastUsedIndex(equationArray) loop
      
          1/2✓ Branch 1 taken 1663731 times.
✗ Branch 2 not taken.

        1663731
              if ExpandableArray.occupied(i, equationArray) then
      
        1663731
                eqn := ExpandableArray.get(i, equationArray);
      
        1663731
                (eqn_new, extraArg) := BackendEquation.traverseExpsOfEquation(eqn, func, extraArg);
      
          1/2✓ Branch 0 taken 1663731 times.
✗ Branch 1 not taken.

        1663731
                if not referenceEq(eqn, eqn_new) then
      
        1663731
                  ExpandableArray.update(i, eqn_new, equationArray);
      
                end if;
      
              end if;
      
            end for;
      
          else
      
        ✗
            if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Debug.trace("- BackendDAE.traverseBackendDAEExpsEqns failed for " + name + "\n");
      
            end if;
      
        ✗
            fail();
      
          end try;
      
        end traverseBackendDAEExpsEqns;
      
        public function traverseBackendDAEExpsEqnsWithStop<T> "author: lochel"
      
          input BackendDAE.EquationArray equationArray;
      
          input FuncExpType func;
      
          input output T extraArg;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input T inTypeA;
      
            output DAE.Exp outExp;
      
            output Boolean cont;
      
            output T outA;
      
          end FuncExpType;
      
        protected
      
          String name;
      
          BackendDAE.Equation e;
      
          Boolean continue_;
      
        algorithm
      
          try
      
          1/2✓ Branch 1 taken 2949 times.
✗ Branch 2 not taken.

        41639
            for i in 1:ExpandableArray.getLastUsedIndex(equationArray) loop
      
          1/2✓ Branch 1 taken 38874 times.
✗ Branch 2 not taken.

        38874
              if ExpandableArray.occupied(i, equationArray) then
      
        38874
                e := ExpandableArray.get(i, equationArray);
      
        38874
                (continue_, extraArg) := BackendEquation.traverseExpsOfEquation_WithStop(e, func, extraArg);
      
          2/2✓ Branch 0 taken 38690 times.
✓ Branch 1 taken 184 times.

        38874
                if not continue_ then
      
                  break;
      
                end if;
      
              end if;
      
            end for;
      
          else
      
        ✗
            if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
              (_, _, name) := System.dladdr(func);
      
        ✗
              Error.addInternalError("BackendDAEUtil.traverseBackendDAEExpsEqnsWithStop failed for " + name, sourceInfo());
      
            end if;
      
        ✗
            fail();
      
          end try;
      
        end traverseBackendDAEExpsEqnsWithStop;
      
        public function traverseBackendDAEExpsOptEqn "author: Frenkel TUD 2010-11
      
          Helper for traverseExpsOfEquation."
      
          replaceable type Type_a subtypeof Any;
      
          input Option<BackendDAE.Equation> inEquation;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
        143
          (_,outTypeA) := traverseBackendDAEExpsOptEqnWithUpdate(inEquation,func,inTypeA);
      
        end traverseBackendDAEExpsOptEqn;
      
        protected function traverseBackendDAEExpsOptEqnWithUpdate "author: Frenkel TUD 2010-11
      
          Helper for traverseExpsOfEquation."
      
          replaceable type Type_a subtypeof Any;
      
          input Option<BackendDAE.Equation> inEquation;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Option<BackendDAE.Equation> outEquation;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          (outEquation,outTypeA) := match inEquation
      
            local
      
              BackendDAE.Equation eqn1,eqn2;
      
             Type_a ext_arg_1;
      
            case SOME(eqn1)
      
              algorithm
      
        143
                (eqn2,ext_arg_1) := BackendEquation.traverseExpsOfEquation(eqn1,func,inTypeA);
      
          1/2✓ Branch 0 taken 143 times.
✗ Branch 1 not taken.

        286
              then
      
                (if referenceEq(eqn1,eqn2) then inEquation else SOME(eqn2),ext_arg_1);
      
            else (NONE(),inTypeA);
      
          end match;
      
        end traverseBackendDAEExpsOptEqnWithUpdate;
      
        public function traverseAlgorithmExpsWithUpdate "
      
          This function goes through the Algorithm structure and finds all the
      
          expressions and performs the function on them
      
        "
      
          replaceable type Type_a subtypeof Any;
      
          input DAE.Algorithm inAlgorithm;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output DAE.Algorithm outAlgorithm;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          (outAlgorithm,outTypeA) := match inAlgorithm
      
            local
      
              list<DAE.Statement> stmts,stmts1;
      
              Type_a ext_arg_1;
      
              DAE.Algorithm alg;
      
            case DAE.ALGORITHM_STMTS(statementLst = stmts)
      
              algorithm
      
        ✗
                (stmts1,ext_arg_1) := DAEUtil.traverseDAEEquationsStmts(stmts,func,inTypeA);
      
        ✗
                alg := if referenceEq(stmts,stmts1) then inAlgorithm else DAE.ALGORITHM_STMTS(stmts1);
      
        ✗
              then
      
                (alg,ext_arg_1);
      
          end match;
      
        end traverseAlgorithmExpsWithUpdate;
      
        protected function traverseZeroCrossingExps
      
          replaceable type Type_a subtypeof Any;
      
          input list<BackendDAE.ZeroCrossing> iZeroCrossing;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          input list<BackendDAE.ZeroCrossing> iAcc={};
      
          output list<BackendDAE.ZeroCrossing> oZeroCrossing;
      
          output Type_a outTypeA;
      
          partial function FuncExpType
      
            input DAE.Exp inExp;
      
            input Type_a inTypeA;
      
            output DAE.Exp outExp;
      
            output Type_a outA;
      
          end FuncExpType;
      
        algorithm
      
          (oZeroCrossing,outTypeA) := match iZeroCrossing
      
            local
      
              list<BackendDAE.ZeroCrossing> zeroCrossing;
      
              DAE.Exp relation1;
      
              Type_a arg;
      
              BackendDAE.ZeroCrossing zc;
      
        ✗
            case {} then (listReverse(iAcc),inTypeA);
      
            case (zc as BackendDAE.ZERO_CROSSING())::zeroCrossing
      
              algorithm
      
        ✗
                (relation1,arg) := Expression.traverseExpBottomUp(zc.relation_,func,inTypeA);
      
        ✗
                (zeroCrossing,arg) := traverseZeroCrossingExps(zeroCrossing,func,arg,(if referenceEq(relation1,zc.relation_) then zc else BackendDAE.ZERO_CROSSING(zc.index,relation1,zc.occurEquLst,zc.iter))::iAcc);
      
              then
      
                (zeroCrossing,arg);
      
          end match;
      
        end traverseZeroCrossingExps;
      
        /*************************************************
      
         * Equation System Pipeline
      
         ************************************************/
      
        public function getSolvedSystem "Run the equation system pipeline."
      
          input BackendDAE.BackendDAE inDAE;
      
          input String fileNamePrefix;
      
          input Option<list<String>> strPreOptModules = NONE();
      
          input Option<String> strmatchingAlgorithm = NONE();
      
          input Option<String> strdaeHandler = NONE();
      
          input Option<list<String>> strPostOptModules = NONE();
      
          output BackendDAE.BackendDAE outSimDAE;
      
          output BackendDAE.BackendDAE outInitDAE;
      
          output Option<BackendDAE.BackendDAE> outInitDAE_lambda0_option;
      
          output Option<BackendDAE.InlineData > outInlineData;
      
          output list<BackendDAE.Equation> outRemovedInitialEquationLst;
      
        protected
      
          BackendDAE.BackendDAE dae, simDAE, outInitDAE_lambda0;
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> preOptModules;
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> postOptModules;
      
          tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc, String, BackendDAEFunc.stateDeselectionFunc, String> daeHandler;
      
          tuple<BackendDAEFunc.matchingAlgorithmFunc, String> matchingAlgorithm;
      
          BackendDAE.Variables globalKnownVars;
      
          Integer numCheckpoints, oldSize;
      
          AvlTreePathFunction.Tree funcTree;
      
        algorithm
      
        1080
          numCheckpoints:=ErrorExt.getNumCheckpoints();
      
          try
      
        1080
          StackOverflow.clearStacktraceMessages();
      
        1080
          setGlobalRoot(Global.adjacencyIfCondCache, NONE());
      
        1080
          preOptModules := getPreOptModules(strPreOptModules);
      
        1080
          postOptModules := getPostOptModules(strPostOptModules);
      
        1080
          matchingAlgorithm := getMatchingAlgorithm(strmatchingAlgorithm);
      
        1080
          daeHandler := getIndexReductionMethod(strdaeHandler);
      
          4/4✓ Branch 1 taken 1079 times.
✓ Branch 2 taken 1 time.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 1077 times.

        1080
          if Flags.isSet(Flags.DUMP_DAE_LOW) or Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        3
            BackendDump.dumpBackendDAE(inDAE, "dumpdaelow (before pre-optimization)");
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.

        3
            if Flags.isSet(Flags.ADDITIONAL_GRAPHVIZ_DUMP) then
      
        ✗
              BackendDump.graphvizAdjacencyMatrix(inDAE, "dumpdaelow");
      
            end if;
      
          end if;
      
          // pre-optimization phase
      
        1080
          dae := preOptimizeDAE(inDAE, preOptModules);
      
        1078
          execStat("pre-optimization done (n="+String(daeSize(dae))+")");
      
          // transformation phase (matching and sorting using index reduction method)
      
        1078
          Error.checkCancel();
      
        1078
          dae := causalizeDAE(dae, NONE(), matchingAlgorithm, daeHandler, true);
      
        1077
          execStat("matching and sorting (n="+String(daeSize(dae))+")");
      
          // synchronous features post-phase
      
        1077
          dae := SynchronousFeatures.synchronousFeatures(dae);
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1075 times.

        1077
          if Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        2
            BackendDump.dumpBackendDAE(dae, "synchronousFeatures");
      
          end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1077 times.

        1077
          if Flags.isSet(Flags.GRAPHML) then
      
        ✗
            BackendDump.dumpBipartiteGraphDAE(dae, fileNamePrefix);
      
          end if;
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1076 times.

        1077
          if Flags.isSet(Flags.EVAL_OUTPUT_ONLY) then
      
        1
            oldSize := daeSize(dae);
      
        1
            dae := BackendDAEOptimize.evaluateOutputsOnly(dae);
      
        1
            execStat("evaluateOutputsOnly (n=" + intString(oldSize) + " -> n=" + intString(daeSize(dae)) + ")");
      
          end if;
      
          //generate Jacobian for StateSets for initial state selection
      
        1077
          Error.checkCancel();
      
        1077
          dae := SymbolicJacobian.calculateStateSetsJacobians(dae);
      
          // generate system for initialization
      
        1077
          Error.checkCancel();
      
        1077
          (outInitDAE, outInitDAE_lambda0_option, outRemovedInitialEquationLst, globalKnownVars, dae) := Initialization.solveInitialSystem(dae);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1076 times.

        1076
          if Flags.isSet(Flags.WARN_NO_NOMINAL) then
      
        ✗
            warnAboutIterationVariablesWithNoNominal(outInitDAE);
      
          end if;
      
          // use function tree from initDAE further for simDAE
      
        1076
          simDAE := BackendDAEUtil.setFunctionTree(dae, BackendDAEUtil.getFunctions(outInitDAE.shared));
      
          // Set updated globalKnownVars
      
        1076
          simDAE := setDAEGlobalKnownVars(simDAE, globalKnownVars);
      
          // add initial assignmnents to all algorithms
      
        1076
          simDAE := BackendDAEOptimize.addInitialStmtsToAlgorithms(simDAE, false);
      
          // remove homotopy and initial calls
      
        1076
          simDAE := Initialization.removeInitializationStuff(simDAE);
      
          // generate inline solver
      
        1076
          outInlineData := SymbolicImplicitSolver.symSolver(simDAE);
      
          // post-optimization phase
      
        1076
          simDAE := postOptimizeDAE(simDAE, postOptModules, matchingAlgorithm, daeHandler);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1076 times.

        1076
          if Flags.isSet(Flags.WARN_NO_NOMINAL) then
      
        ✗
            warnAboutIterationVariablesWithNoNominal(simDAE);
      
          end if;
      
          // sort the globalKnownVars
      
        1076
          simDAE := sortGlobalKnownVarsInDAE(simDAE);
      
        1076
          execStat("sort global known variables");
      
          // remove unused functions
      
        1076
          funcTree := BackendDAEOptimize.copyRecordConstructorAndExternalObjConstructorDestructor(BackendDAEUtil.getFunctions(simDAE.shared));
      
        1076
          funcTree := BackendDAEOptimize.removeUnusedFunctions(outInitDAE.eqs, outInitDAE.shared, outRemovedInitialEquationLst, BackendDAEUtil.getFunctions(simDAE.shared), funcTree);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 1076 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 1043 times.

        1076
          if isSome(outInitDAE_lambda0_option) then
      
        33
            SOME(outInitDAE_lambda0) := outInitDAE_lambda0_option;
      
        33
            funcTree := BackendDAEOptimize.removeUnusedFunctions(outInitDAE_lambda0.eqs, simDAE.shared, {}, BackendDAEUtil.getFunctions(simDAE.shared), funcTree);
      
          end if;
      
        1076
          funcTree := BackendDAEOptimize.removeUnusedFunctions(simDAE.eqs, simDAE.shared, {}, BackendDAEUtil.getFunctions(simDAE.shared), funcTree);
      
        1075
          outSimDAE := BackendDAEUtil.setFunctionTree(simDAE, funcTree);
      
        1075
          execStat("remove unused functions");
      
          2/2✓ Branch 1 taken 6 times.
✓ Branch 2 taken 1069 times.

        1075
          if Flags.isSet(Flags.DUMP_INDX_DAE) then
      
        6
            BackendDump.dumpBackendDAE(outSimDAE, "dumpindxdae");
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.

        6
            if Flags.isSet(Flags.ADDITIONAL_GRAPHVIZ_DUMP) then
      
        ✗
              BackendDump.graphvizBackendDAE(outSimDAE, "dumpindxdae");
      
            end if;
      
          end if;
      
          4/6✓ Branch 1 taken 1016 times.
✓ Branch 2 taken 59 times.
✓ Branch 4 taken 1016 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 1016 times.

        1075
          if Flags.isSet(Flags.DUMP_BACKENDDAE_INFO) or Flags.isSet(Flags.DUMP_STATESELECTION_INFO) or Flags.isSet(Flags.DUMP_DISCRETEVARS_INFO) then
      
        59
            BackendDump.dumpCompShort(outSimDAE);
      
          end if;
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1074 times.

        1075
          if Flags.isSet(Flags.DUMP_EQNINORDER) then
      
        1
            BackendDump.dumpEqnsSolved(outSimDAE, "indxdae: eqns in order");
      
          end if;
      
          3/4✓ Branch 1 taken 1073 times.
✓ Branch 2 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1073 times.

        1075
          if Flags.isSet(Flags.DUMP_LOOPS) or Flags.isSet(Flags.DUMP_LOOPS_VERBOSE) then
      
        2
            print("\n" + BackendDump.BORDER + "\n\n Algbraic Loops (Simulation): \n\n" + BackendDump.BORDER + "\n");
      
        2
            BackendDump.dumpLoops(outSimDAE);
      
        2
            print("\n" + BackendDump.BORDER + "\n\n Algbraic Loops (Initialization): \n\n" + BackendDump.BORDER + "\n");
      
        2
            BackendDump.dumpLoops(outInitDAE);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

        2
            if isSome(outInitDAE_lambda0_option) then
      
        ✗
              print("\n" + BackendDump.BORDER + "\n\n Algbraic Loops (Initialization Lambda=0 (Homotopy)): \n\n" + BackendDump.BORDER + "\n");
      
        ✗
              BackendDump.dumpLoops(Util.getOption(outInitDAE_lambda0_option));
      
            end if;
      
          end if;
      
        1075
          checkBackendDAEWithErrorMsg(outSimDAE);
      
          2/2✓ Branch 0 taken 1061 times.
✓ Branch 1 taken 14 times.

        1075
          return;
      
          else
      
        ✗
          setGlobalRoot(Global.stackoverFlowIndex, NONE());
      
        ✗
          ErrorExt.rollbackNumCheckpoints(ErrorExt.getNumCheckpoints()-numCheckpoints);
      
          // A user cancel unwinds through this checkpoint like a failure; report it as
      
          // such (after the rollback, so the message survives) rather than as overflow.
      
        ✗
          Error.checkCancel();
      
        ✗
          Error.addInternalError(StackOverflow.errorPrefix() + " in "+getInstanceName()+"...\n"+stringDelimitList(StackOverflow.readableStacktraceMessages(), "\n"), sourceInfo());
      
          /* Do not fail or we can loop too much */
      
        ✗
          StackOverflow.clearStacktraceMessages();
      
          end try annotation(__OpenModelica_stackOverflowCheckpoint=true);
      
        ✗
          fail();
      
        end getSolvedSystem;
      
        public function preOptimizeBackendDAE "
      
          This function runs the pre-optimization modules."
      
          input BackendDAE.BackendDAE inDAE;
      
          input Option<list<String>> strPreOptModules;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> preOptModules;
      
        algorithm
      
        2
          preOptModules := getPreOptModules(strPreOptModules);
      
        2
          outDAE := preOptimizeDAE(inDAE, preOptModules);
      
        end preOptimizeBackendDAE;
      
        public function preOptimizeDAE "
      
          This function runs the pre-optimization modules."
      
          input BackendDAE.BackendDAE inDAE;
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> inPreOptModules;
      
          output BackendDAE.BackendDAE outDAE = inDAE;
      
        protected
      
          BackendDAEFunc.optimizationModule optModule;
      
          String moduleStr;
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        2845
          execStat("prepare preOptimizeDAE");
      
          2/2✓ Branch 0 taken 20544 times.
✓ Branch 1 taken 2843 times.

        23387
          for preOptModule in inPreOptModules loop
      
        20544
            Error.checkCancel();
      
        20544
            (optModule, moduleStr) := preOptModule;
      
        20544
            moduleStr := moduleStr + " (" + BackendDump.printBackendDAEType2String(inDAE.shared.backendDAEType) + ")";
      
            try
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20544 times.

        20544
              BackendDAE.DAE(systs, shared) := optModule(outDAE);
      
        20542
              (systs, shared) := filterEmptySystems(systs, shared);
      
        20542
              outDAE := BackendDAE.DAE(systs, shared);
      
        20542
              execStat("preOpt " + moduleStr);
      
          2/2✓ Branch 1 taken 15 times.
✓ Branch 2 taken 20527 times.

        20542
              if Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        15
                BackendDump.dumpBackendDAE(outDAE, "pre-optimization module " + moduleStr);
      
              end if;
      
            else
      
        2
              execStat("preOpt " + moduleStr + " <failed>");
      
        2
              Error.addCompilerError("pre-optimization module " + moduleStr + " failed.");
      
        2
              fail();
      
            end try;
      
          end for;
      
          2/2✓ Branch 1 taken 2841 times.
✓ Branch 2 taken 2 times.

        2843
          if Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        2
            print("pre-optimization done.\n");
      
          end if;
      
        end preOptimizeDAE;
      
        public function transformBackendDAE "
      
          Run the matching and index reduction algorithm"
      
          input BackendDAE.BackendDAE inDAE;
      
          input Option<BackendDAE.MatchingOptions> inMatchingOptions;
      
          input Option<String> strmatchingAlgorithm;
      
          input Option<String> strindexReductionMethod;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          tuple<BackendDAEFunc.matchingAlgorithmFunc,String> matchingAlgorithm;
      
          tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> indexReductionMethod;
      
        algorithm
      
        6438
          matchingAlgorithm := getMatchingAlgorithm(strmatchingAlgorithm);
      
        6438
          indexReductionMethod := getIndexReductionMethod(strindexReductionMethod);
      
        6438
          outDAE := causalizeDAE(inDAE,inMatchingOptions,matchingAlgorithm,indexReductionMethod,true);
      
        end transformBackendDAE;
      
        public function causalizeDAE "
      
          Run the matching Algorithm.
      
          In case of a DAE a DAE handler is used to reduce the index of the DAE."
      
          input BackendDAE.BackendDAE inDAE;
      
          input Option<BackendDAE.MatchingOptions> inMatchingOptions;
      
          input tuple<BackendDAEFunc.matchingAlgorithmFunc,String> matchingAlgorithm;
      
          input tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> stateDeselection;
      
          input Boolean dolateinline;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
          list<Option<BackendDAE.StructurallySingularSystemHandlerArg>> args;
      
          Boolean causalized;
      
        algorithm
      
        49351
          BackendDAE.DAE(systs,shared) := inDAE;
      
          // reduce index
      
        49351
          (systs,shared,args,causalized) := mapCausalizeDAE(systs,shared,inMatchingOptions,matchingAlgorithm,stateDeselection,{},{},false);
      
          // do late inline
      
          2/2✓ Branch 0 taken 9278 times.
✓ Branch 1 taken 40072 times.

        49350
          outDAE := if dolateinline then BackendInline.lateInlineFunction(BackendDAE.DAE(systs,shared)) else BackendDAE.DAE(systs,shared);
      
            //print("The StructurallySingularSystemHandlerArgs\n");
      
            //List.map_0(args,BackendDump.SSSHandlerArgString);
      
          // do state selection
      
          2/2✓ Branch 0 taken 12075 times.
✓ Branch 1 taken 37275 times.

        49350
          if causalized then
      
        12075
            BackendDAE.DAE(systs,shared) := stateDeselectionDAE(outDAE, args, stateDeselection);
      
          end if;
      
          // sort assigned equations to blt form
      
        49350
          systs := mapSortEqnsDAE(systs, shared);
      
        49350
          outDAE := BackendDAE.DAE(systs, shared);
      
        end causalizeDAE;
      
        protected function mapCausalizeDAE "
      
          Run the matching Algorithm.
      
          In case of a DAE a DAE handler is used to reduce the index of the DAE."
      
          input list<BackendDAE.EqSystem> isysts;
      
          input BackendDAE.Shared ishared;
      
          input Option<BackendDAE.MatchingOptions> inMatchingOptions;
      
          input tuple<BackendDAEFunc.matchingAlgorithmFunc,String> matchingAlgorithm;
      
          input tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> stateDeselection;
      
          input list<BackendDAE.EqSystem> acc;
      
          input list<Option<BackendDAE.StructurallySingularSystemHandlerArg>> acc1;
      
          input Boolean iCausalized;
      
          output list<BackendDAE.EqSystem> osysts;
      
          output BackendDAE.Shared oshared;
      
          output list<Option<BackendDAE.StructurallySingularSystemHandlerArg>> oargs;
      
          output Boolean oCausalized;
      
        algorithm
      
          (osysts,oshared,oargs,oCausalized) := match isysts
      
            local
      
              BackendDAE.EqSystem syst;
      
              list<BackendDAE.EqSystem> systs;
      
              BackendDAE.Shared shared;
      
              Option<BackendDAE.StructurallySingularSystemHandlerArg> arg;
      
              list<Option<BackendDAE.StructurallySingularSystemHandlerArg>> args;
      
              Boolean causalized;
      
            case {}
      
        49350
            then (listReverse(acc),ishared,listReverse(acc1),iCausalized);
      
            case syst::systs algorithm
      
        414933
              Error.checkCancel();
      
        414933
              (syst,shared,arg,causalized) := causalizeDAEWork(syst,ishared,inMatchingOptions,matchingAlgorithm,stateDeselection,iCausalized);
      
        414932
              (systs,shared,args,causalized) := mapCausalizeDAE(systs,shared,inMatchingOptions,matchingAlgorithm,stateDeselection,syst::acc,arg::acc1,causalized);
      
            then (systs,shared,args,causalized);
      
          end match;
      
        end mapCausalizeDAE;
      
        protected function causalizeDAEWork "
      
          Run the matching Algorithm.
      
          In case of an DAE an DAE-Handler is used to reduce
      
          the index of the dae."
      
          input BackendDAE.EqSystem isyst;
      
          input BackendDAE.Shared ishared;
      
          input Option<BackendDAE.MatchingOptions> inMatchingOptions;
      
          input tuple<BackendDAEFunc.matchingAlgorithmFunc,String> matchingAlgorithm;
      
          input tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> stateDeselection;
      
          input Boolean iCausalized;
      
          output BackendDAE.EqSystem osyst;
      
          output BackendDAE.Shared oshared;
      
          output Option<BackendDAE.StructurallySingularSystemHandlerArg> oArg;
      
          output Boolean oCausalized;
      
        algorithm
      
          (osyst,oshared,oArg,oCausalized) := matchcontinue (isyst,matchingAlgorithm,stateDeselection)
      
            local
      
              array<Integer> mapIncRowEqn;
      
              array<list<Integer>> mapEqnIncRow;
      
              BackendDAE.EqSystem syst;
      
              BackendDAE.MatchingOptions match_opts;
      
              BackendDAE.Shared shared;
      
              BackendDAE.StructurallySingularSystemHandlerArg arg;
      
              BackendDAEFunc.matchingAlgorithmFunc matchingAlgorithmfunc;
      
              BackendDAEFunc.StructurallySingularSystemHandlerFunc sssHandler;
      
              AvlTreePathFunction.Tree funcs;
      
              Integer nvars,neqns;
      
              String str,mAmethodstr,str1;
      
            case (BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING()), _, _)
      
            then (isyst, ishared,NONE(), iCausalized);
      
            case (BackendDAE.EQSYSTEM(matching=BackendDAE.NO_MATCHING()), (matchingAlgorithmfunc,_), (sssHandler,_,_,_)) algorithm
      
              //BackendDump.dumpEqSystem(isyst, "causalizeDAEWork");
      
              //print("SystemSize: " + intString(systemSize(isyst)));
      
        61588
              funcs := getFunctions(ishared);
      
        123176
              (syst,_,_,mapEqnIncRow,mapIncRowEqn) := getAdjacencyMatrixScalar(isyst,BackendDAE.SOLVABLE(), SOME(funcs), isInitializationDAE(ishared));
      
        61588
              match_opts := Util.getOptionOrDefault(inMatchingOptions,(BackendDAE.INDEX_REDUCTION(), BackendDAE.EXACT()));
      
        61588
              arg := IndexReduction.getStructurallySingularSystemHandlerArg(syst,ishared,mapEqnIncRow,mapIncRowEqn);
      
              // check singular system
      
        61588
              nvars := BackendVariable.daenumVariables(syst);
      
        61588
              neqns := systemSize(syst);
      
        61588
              syst := Causalize.singularSystemCheck(nvars,neqns,syst,match_opts,matchingAlgorithm,arg,ishared);
      
              // execStat("transformDAE -> singularSystemCheck " + mAmethodstr);
      
              // match the system and reduce index if neccessary
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61587 times.

        61587
              (syst,shared,arg) := matchingAlgorithmfunc(syst, ishared, false, match_opts, sssHandler, arg);
      
              // execStat("transformDAE -> matchingAlgorithm " + mAmethodstr + " index Reduction Method " + str1);
      
        61587
            then (syst, shared,SOME(arg), true);
      
            case (_, (_,mAmethodstr), (_,str1,_,_)) algorithm
      
              // A cancel unwinds through here; do not blame the module for it.
      
        1
              Error.checkCancel();
      
        1
              str := "Transformation Module " + mAmethodstr + " index Reduction Method " + str1 + " failed!";
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        1
              if not isInitializationDAE(ishared) then
      
        1
                Error.addMessage(Error.INTERNAL_ERROR, {str});
      
              end if;
      
        1
            then fail();
      
          end matchcontinue;
      
        end causalizeDAEWork;
      
        protected function stateDeselectionDAE
      
          input BackendDAE.BackendDAE inDAE;
      
          input list<Option<BackendDAE.StructurallySingularSystemHandlerArg>> args;
      
          input tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> stateDeselection;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          String methodstr;
      
          BackendDAEFunc.stateDeselectionFunc sDfunc;
      
        algorithm
      
          // do state selection
      
        12075
          (_, _, sDfunc, methodstr) := stateDeselection;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12075 times.

        12075
          outDAE := sDfunc(inDAE, args);
      
          //execStat("transformDAE -> state selection " + methodstr);
      
        end stateDeselectionDAE;
      
        protected function mapSortEqnsDAE "Run Tarjan's Algorithm."
      
          input list<BackendDAE.EqSystem> inSystem;
      
          input BackendDAE.Shared inShared;
      
          output list<BackendDAE.EqSystem> outSystem;
      
        algorithm
      
          4/4✓ Branch 0 taken 414932 times.
✓ Branch 1 taken 49350 times.
✓ Branch 2 taken 414932 times.
✓ Branch 3 taken 49350 times.

        464282
          outSystem := list(match syst
      
            case BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=_::_)) then syst;
      
            else algorithm
      
        61588
              Error.checkCancel();
      
        61588
            then sortEqnsDAEWork(syst, inShared);
      
          end match for syst in inSystem);
      
        end mapSortEqnsDAE;
      
        protected function sortEqnsDAEWork "Run Tarjans Algorithm."
      
          input BackendDAE.EqSystem inSystem;
      
          input BackendDAE.Shared inShared;
      
          output BackendDAE.EqSystem outSystem;
      
        protected
      
          BackendDAE.EqSystem syst;
      
          array<list<Integer>> mapEqnIncRow;
      
          array<Integer> mapIncRowEqn;
      
          AvlTreePathFunction.Tree funcs;
      
        algorithm
      
          try
      
            // sorting algorithm
      
        61588
            funcs := getFunctions(inShared);
      
        123176
            (syst, _, _, mapEqnIncRow, mapIncRowEqn) := getAdjacencyMatrixScalar(inSystem, BackendDAE.NORMAL(), SOME(funcs), isInitializationDAE(inShared));
      
        61588
            (outSystem, _) := BackendDAETransform.strongComponentsScalar(syst, inShared, mapEqnIncRow, mapIncRowEqn);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 61588 times.

        61588
            if Flags.isSet(Flags.DUMP_SCC_GRAPHML) then
      
        ✗
              dumpStrongComponents(outSystem, inShared);
      
            end if;
      
          else
      
            //BackendDump.dumpEqSystem(inSystem, "Transformation module sort components failed for following system:");
      
        ✗
            Error.addInternalError("Transformation module sort components failed", sourceInfo());
      
        ✗
            fail();
      
          end try;
      
        end sortEqnsDAEWork;
      
        function dumpStrongComponents
      
        "dump the strongly connected components on a flag"
      
          input BackendDAE.EqSystem isyst;
      
          input BackendDAE.Shared ishared;
      
        algorithm
      
          () := match ishared
      
            local
      
              String fileName, fileNamePrefix;
      
              Integer seqNo;
      
            case BackendDAE.SHARED(info = BackendDAE.EXTRA_INFO(fileNamePrefix = fileNamePrefix))
      
              algorithm
      
        ✗
                seqNo := System.tmpTickIndex(Global.backendDAE_fileSequence);
      
        ✗
                fileName := fileNamePrefix + "_" + intString(seqNo) + "_Comps" + intString(systemSize(isyst)) + ".graphml";
      
        ✗
                DumpGraphML.dumpSystem(isyst, ishared, NONE(), fileName, false);
      
              then ();
      
          end match;
      
        end dumpStrongComponents;
      
        public function postOptimizeDAE
      
          "Run the post-optimization modules."
      
          input BackendDAE.BackendDAE inDAE;
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> inPostOptModules;
      
          input tuple<BackendDAEFunc.matchingAlgorithmFunc, String> inMatchingAlgorithm;
      
          input tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc, String, BackendDAEFunc.stateDeselectionFunc, String> inDAEHandler;
      
          output BackendDAE.BackendDAE outDAE = inDAE;
      
        protected
      
          BackendDAEFunc.optimizationModule optModule;
      
          String moduleStr;
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.Shared shared;
      
          constant Boolean debug = false;
      
        algorithm
      
        3959
          execStat("prepare postOptimizeDAE");
      
          2/2✓ Branch 0 taken 40072 times.
✓ Branch 1 taken 3959 times.

        44031
          for postOptModule in inPostOptModules loop
      
        40072
            Error.checkCancel();
      
        40072
            (optModule, moduleStr) := postOptModule;
      
        40072
            moduleStr := moduleStr + " (" + BackendDump.printBackendDAEType2String(inDAE.shared.backendDAEType) + ")";
      
            try
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 40072 times.

        40072
              BackendDAE.DAE(systs, shared) := optModule(outDAE);
      
        40072
              (systs, shared) := filterEmptySystems(systs, shared);
      
        40072
              outDAE := BackendDAE.DAE(systs, shared);
      
              if debug then execStat("postOpt " + moduleStr); end if;
      
        40072
              outDAE := causalizeDAE(outDAE, SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())), inMatchingAlgorithm, inDAEHandler, false);
      
        40072
              execStat("postOpt " + (if debug then "causalize " else "") + moduleStr);
      
          2/2✓ Branch 1 taken 31 times.
✓ Branch 2 taken 40041 times.

        40072
              if Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        31
                BackendDump.dumpBackendDAE(outDAE, "post-optimization module " + moduleStr);
      
              end if;
      
            else
      
        ✗
              execStat("<failed> postOpt " + moduleStr);
      
        ✗
              Error.addCompilerError("post-optimization module " + moduleStr + " failed.");
      
        ✗
              fail();
      
            end try;
      
          end for;
      
          2/2✓ Branch 1 taken 3955 times.
✓ Branch 2 taken 4 times.

        3959
          if Flags.isSet(Flags.OPT_DAE_DUMP) then
      
        4
            print("post-optimization done.\n");
      
          end if;
      
        end postOptimizeDAE;
      
        public function getSolvedSystemforJacobians "Run the equation system pipeline."
      
          input BackendDAE.BackendDAE inDAE;
      
          input list<String> strPreOptModules;
      
          input Option<String> strMatchingAlgorithm;
      
          input Option<String> strDAEHandler;
      
          input list<String> strPostOptModules;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.BackendDAE dae;
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> preOptModules;
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> postOptModules;
      
          tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc, String, BackendDAEFunc.stateDeselectionFunc, String> daeHandler;
      
          tuple<BackendDAEFunc.matchingAlgorithmFunc, String> matchingAlgorithm;
      
        algorithm
      
        1754
          preOptModules := selectOptModules(strPreOptModules, {}, {}, allPreOptimizationModules());
      
        1754
          postOptModules := selectOptModules(strPostOptModules, {}, {}, allPostOptimizationModules());
      
        1754
          matchingAlgorithm := getMatchingAlgorithm(strMatchingAlgorithm);
      
        1754
          daeHandler := getIndexReductionMethod(strDAEHandler);
      
          //fcall2(Flags.DUMP_DAE_LOW, BackendDump.dumpBackendDAE, inDAE, "dumpdaelow");
      
          // pre optimisation phase
      
        1754
          dae := preOptimizeDAE(inDAE, preOptModules);
      
          // transformation phase (matching and sorting using a index reduction method
      
        1754
          dae := causalizeDAE(dae, SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())), matchingAlgorithm, daeHandler, true);
      
        1754
          execStat("causalizeDAE (first run)");
      
          //fcall(Flags.DUMP_DAE_LOW, BackendDump.bltdump, ("bltdump", dae));
      
          // post-optimization phase
      
        1754
          outDAE := postOptimizeDAE(dae, postOptModules, matchingAlgorithm, daeHandler);
      
          //fcall2(Flags.DUMP_INDX_DAE, BackendDump.dumpBackendDAE, outDAE, "dumpindxdae");
      
          //bcall(Flags.isSet(Flags.DUMP_BACKENDDAE_INFO) or Flags.isSet(Flags.DUMP_STATESELECTION_INFO) or Flags.isSet(Flags.DUMP_DISCRETEVARS_INFO), BackendDump.dumpCompShort, outDAE);
      
          //fcall2(Flags.DUMP_EQNINORDER, BackendDump.dumpEqnsSolved, outDAE, "system for jacobians");
      
        end getSolvedSystemforJacobians;
      
        public function sortGlobalKnownVarsInDAE "
      
        author: ptaeuber
      
        This function sorts the globalKnownVars"
      
          input output BackendDAE.BackendDAE backendDAE;
      
        protected
      
          BackendDAE.Variables globalKnownVars, globalKnownVars_sorted;
      
          BackendDAE.EquationArray parameterEqns;
      
          BackendDAE.EqSystem paramSystem;
      
          BackendDAE.AdjacencyMatrix m;
      
          BackendDAE.Var var;
      
          array<Integer> ass1, ass2;
      
          list<list<Integer>> comps;
      
          list<Integer> flatComps;
      
        algorithm
      
        1085
          globalKnownVars := backendDAE.shared.globalKnownVars;
      
        1085
          parameterEqns := BackendEquation.emptyEqnsSized(BackendVariable.varsSize(globalKnownVars));
      
        1085
          parameterEqns := BackendVariable.traverseBackendDAEVars(globalKnownVars, createGlobalKnownVarsEquations, parameterEqns);
      
        1085
          paramSystem := BackendDAEUtil.createEqSystem(globalKnownVars, parameterEqns);
      
        1085
          (m, _) := BackendDAEUtil.adjacencyMatrix(paramSystem, BackendDAE.NORMAL(), NONE(), isInitializationDAE(backendDAE.shared));
      
        1085
          (ass1, ass2) := Matching.PerfectMatching(m);
      
        1085
          comps := Sorting.Tarjan(m, ass1);
      
          4/4✓ Branch 0 taken 185937 times.
✓ Branch 1 taken 1085 times.
✓ Branch 2 taken 185937 times.
✓ Branch 3 taken 1085 times.

        187022
          flatComps := list(Initialization.flattenParamComp(comp, globalKnownVars) for comp in comps);
      
        1085
          globalKnownVars_sorted := BackendVariable.emptyVarsSized(BackendVariable.varsSize(globalKnownVars));
      
          2/2✓ Branch 0 taken 185937 times.
✓ Branch 1 taken 1085 times.

        187022
          for i in flatComps loop
      
        185937
              var := BackendVariable.getVarAt(globalKnownVars, i);
      
        185937
              globalKnownVars_sorted := BackendVariable.addVar(var, globalKnownVars_sorted);
      
          end for;
      
        1085
          backendDAE := setDAEGlobalKnownVars(backendDAE, globalKnownVars_sorted);
      
        1085
          ExecStat.execStat("sorting global known variables");
      
        end sortGlobalKnownVarsInDAE;
      
        protected function createGlobalKnownVarsEquations
      
          input output BackendDAE.Var var;
      
          input output BackendDAE.EquationArray parameterEqns;
      
        protected
      
          DAE.Exp lhs, rhs;
      
          BackendDAE.Equation eqn;
      
        algorithm
      
        185937
          lhs := BackendVariable.varExp(var);
      
        185937
          rhs := BackendVariable.varBindExpStartValueNoFail(var);
      
        185937
          eqn := BackendDAE.EQUATION(lhs, rhs, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_BINDING);
      
        185937
          parameterEqns := BackendEquation.add(eqn, parameterEqns);
      
        end createGlobalKnownVarsEquations;
      
        public function getEqnIndexArray
      
        "author: kabdelhak FHB 10-2019
      
         Returns the scalar equation indices for an equation array. REMOVABLE?"
      
          input BackendDAE.EquationArray eqs;
      
          output array<list<Integer>> eqIdxArray;
      
        protected
      
          Integer idx = 1, idx2 = 0, size;
      
          list<Integer> eqIdxLst;
      
        algorithm
      
        ✗
          eqIdxArray := arrayCreate(BackendEquation.getNumberOfEquations(eqs), {});
      
        ✗
          for eq in BackendEquation.equationList(eqs) loop
      
        ✗
            size := BackendEquation.equationSize(BackendEquation.get(eqs, idx));
      
        ✗
            eqIdxLst := List.map1(List.intRange(size),intAdd,idx2);
      
        ✗
            arrayUpdate(eqIdxArray, idx, eqIdxLst);
      
        ✗
            idx := idx+1;
      
        ✗
            idx2 := size+idx2;
      
          end for;
      
        end getEqnIndexArray;
      
        public function analyticalToStructuralSingularity
      
        "author: kabdelhak FHB 10-2019
      
         Performs the conversion of analytical to structural singularities by
      
         using gaussian elimination on the linear integer part of the strong
      
         component jacobian and replacing the zero row equations.
      
         Example:
      
          (f1) der(x) = sin(time);
      
          (f2) der(y) = cos(time) + b;
      
          (f3) a +  2b +  x = 3;
      
          (f4) 2a + 4b + 2y = 6;
      
          Jac:
      
          | 1 2 |
      
          | 2 4 | -> linear dependent
      
          (f4) gets replaced by (f4) - 2*(f3) -> 2y - 2x = 0;
      
          "
      
          input list<Integer> comp;
      
          input output array<Integer> ass1;
      
          input output array<Integer> ass2;
      
          input output BackendDAE.EqSystem syst;
      
          input output Boolean changed;
      
          input Boolean init = false;
      
        protected
      
          array<list<Integer>> mapArrayToScalar;
      
          array<Integer> mapScalarToArray;
      
          list<tuple<BackendDAE.Equation, tuple<Integer, Integer>>> loopEqs = {}; /* scalar index needs to be list -- replace lookup with eqnIndexArray*/
      
          list<tuple<BackendDAE.Var, Integer>> loopVars = {};
      
          BackendDAE.Equation tmp_eq;
      
          SymbolicJacobian.LinearJacobian linJac;
      
        algorithm
      
          2/2✓ Branch 1 taken 1574 times.
✓ Branch 2 taken 36187 times.

        37761
          if listLength(comp) > 1 then
      
            /* collect eqs and vars from strong component */
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1574 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1574 times.

        1574
            SOME((mapArrayToScalar, mapScalarToArray, _, _, _)) := syst.mapping;
      
          2/2✓ Branch 0 taken 15669 times.
✓ Branch 1 taken 1574 times.

        17243
            for eqnIndex in comp loop
      
              /* ignore multidimensional equations for now */
      
          2/2✓ Branch 3 taken 8631 times.
✓ Branch 4 taken 7038 times.

        15669
              if listLength(mapArrayToScalar[mapScalarToArray[eqnIndex]]) == 1 then
      
        8631
                tmp_eq := BackendEquation.get(syst.orderedEqs, mapScalarToArray[eqnIndex]);
      
        8631
                loopEqs := (tmp_eq, (mapScalarToArray[eqnIndex], eqnIndex)) :: loopEqs;
      
              else
      
                /*
      
                tmp_eq := BackendEquation.get(syst.orderedEqs, mapScalarToArray[eqnIndex]);
      
                BackendDump.dumpEquationList({tmp_eq}, "ignored array eqs index: " + intString(eqnIndex));
      
                */
      
              end if;
      
        15669
              loopVars := (BackendVariable.getVarAt(syst.orderedVars, ass1[eqnIndex]), ass1[eqnIndex]) :: loopVars;
      
            end for;
      
          4/4✓ Branch 0 taken 662 times.
✓ Branch 1 taken 912 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 908 times.

        1574
            if not listEmpty(loopEqs) and (listLength(loopEqs) <= Flags.getConfigInt(Flags.MAX_SIZE_ASSC)) then
      
              try
      
                /* generate linear integer sub jacobian from system */
      
        908
                linJac := SymbolicJacobian.LinearJacobian.generate(loopEqs, loopVars, ass1);
      
          2/2✓ Branch 1 taken 333 times.
✓ Branch 2 taken 565 times.

        898
                if not SymbolicJacobian.LinearJacobian.emptyOrSingle(linJac) then
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 332 times.

        333
                  if Flags.isSet(Flags.DUMP_ASSC) then
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        2
                    print(SymbolicJacobian.LinearJacobian.toString(linJac, "Original (initial: " + boolString(init) + ")"));
      
                  end if;
      
                  /* solve jacobian with gaussian elimination */
      
        333
                  linJac := SymbolicJacobian.LinearJacobian.solve(linJac);
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 332 times.

        333
                  if Flags.isSet(Flags.DUMP_ASSC) then
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        2
                    print(SymbolicJacobian.LinearJacobian.toString(linJac, "Solved (initial: " + boolString(init) + ")"));
      
                  end if;
      
                  /* set changed to true if it was true before, or any row changed in the jacobian */
      
          4/4✓ Branch 0 taken 175 times.
✓ Branch 1 taken 158 times.
✓ Branch 3 taken 108 times.
✓ Branch 4 taken 67 times.

        333
                  changed := changed or SymbolicJacobian.LinearJacobian.anyChanges(linJac);
      
                  /* resolve zero rows to new equations and update assignments / adjacency matrix */
      
        333
                  (ass1, ass2, syst) := SymbolicJacobian.LinearJacobian.resolveASSC(linJac, ass1, ass2, syst, init);
      
                end if;
      
              else
      
                /* possibly fails if jacobian is empty --- nothing to do */
      
              end try;
      
            end if;
      
          end if;
      
        end analyticalToStructuralSingularity;
      
        /*************************************************
      
         * index reduction method Selection
      
         ************************************************/
      
        public function getIndexReductionMethodString
      
        " function: getIndexReductionMethodString"
      
          output String strIndexReductionMethod;
      
        algorithm
      
        10401
          strIndexReductionMethod := Config.getIndexReductionMethod();
      
        end getIndexReductionMethodString;
      
        public function getIndexReductionMethod
      
        " function: getIndexReductionMethod"
      
          input Option<String> ostrIndexReductionMethod;
      
          output tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String> IndexReductionMethod;
      
        protected
      
          list<tuple<BackendDAEFunc.StructurallySingularSystemHandlerFunc,String,BackendDAEFunc.stateDeselectionFunc,String>> allIndexReductionMethods;
      
          String strIndexReductionMethod;
      
        algorithm
      
        10401
         allIndexReductionMethods := {(IndexReduction.failIfIndexReduction, "none", IndexReduction.noStateDeselection, "none"),
      
                                      (IndexReduction.pantelidesIndexReduction, "Pantelides", IndexReduction.noStateDeselection, "uode"),
      
                                      (IndexReduction.pantelidesIndexReduction, "Pantelides", IndexReduction.dynamicStateSelection, "dynamicStateSelection"),
      
                                      (IndexReduction.pantelidesIndexReduction, "Pantelides", IndexReduction.dynamicStateSelection, "dummyDerivatives")};
      
        10401
         strIndexReductionMethod := getIndexReductionMethodString();
      
        10401
         strIndexReductionMethod := Util.getOptionOrDefault(ostrIndexReductionMethod,strIndexReductionMethod);
      
        10401
         IndexReductionMethod := selectIndexReductionMethod(strIndexReductionMethod,allIndexReductionMethods);
      
        end getIndexReductionMethod;
      
        protected function selectIndexReductionMethod
      
        " function: selectIndexReductionMethod"
      
          input String strIndexReductionMethod;
      
          input list<tuple<Type_a,String,Type_b,String>> inIndexReductionMethods;
      
          output tuple<Type_a,String,Type_b,String> outIndexReductionMethod;
      
          replaceable type Type_a subtypeof Any;
      
          replaceable type Type_b subtypeof Any;
      
        algorithm
      
          outIndexReductionMethod:=
      
          matchcontinue inIndexReductionMethods
      
            local
      
              String name,str;
      
              tuple<Type_a,String,Type_b,String> method;
      
              list<tuple<Type_a,String,Type_b,String>> methods;
      
            case (method as (_,_,_,name))::_
      
              guard
      
                stringEqual(strIndexReductionMethod,name)
      
              then
      
                method;
      
            case _::methods
      
              algorithm
      
        18802
                method := selectIndexReductionMethod(strIndexReductionMethod,methods);
      
              then
      
                method;
      
            else
      
              algorithm
      
        ✗
                str := stringAppendList({"Selection of Index Reduction Method ",strIndexReductionMethod," failed."});
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {str});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end selectIndexReductionMethod;
      
        /*************************************************
      
         * matching Algorithm Selection
      
         ************************************************/
      
        public function getMatchingAlgorithmString
      
        " function: getMatchingAlgorithmString"
      
          output String strMatchingAlgorithm;
      
        algorithm
      
        10401
          strMatchingAlgorithm := Config.getMatchingAlgorithm();
      
        end getMatchingAlgorithmString;
      
        public function getMatchingAlgorithm
      
        " function: getIndexReductionMethod"
      
          input Option<String> ostrMatchingAlgorithm;
      
          output tuple<BackendDAEFunc.matchingAlgorithmFunc,String> matchingAlgorithm;
      
        protected
      
          list<tuple<BackendDAEFunc.matchingAlgorithmFunc,String>> allMatchingAlgorithms;
      
          String strMatchingAlgorithm;
      
        algorithm
      
        10401
         allMatchingAlgorithms := {(Matching.BFSB,"BFSB"),
      
                                   (Matching.DFSB,"DFSB"),
      
                                   (Matching.MC21A,"MC21A"),
      
                                   (Matching.PF,"PF"),
      
                                   (Matching.PFPlus,"PFPlus"),
      
                                   (Matching.HK,"HK"),
      
                                   (Matching.HKDW,"HKDW"),
      
                                   (Matching.ABMP,"ABMP"),
      
                                   (Matching.PR_FIFO_FAIR,"PR"),
      
                                   (Matching.DFSBExternal,"DFSBExt"),
      
                                   (Matching.BFSBExternal,"BFSBExt"),
      
                                   (Matching.MC21AExternal,"MC21AExt"),
      
                                   (Matching.PFExternal,"PFExt"),
      
                                   (Matching.PFPlusExternal,"PFPlusExt"),
      
                                   (Matching.HKExternal,"HKExt"),
      
                                   (Matching.HKDWExternal,"HKDWExt"),
      
                                   (Matching.ABMPExternal,"ABMPExt"),
      
                                   (Matching.PR_FIFO_FAIRExternal,"PRExt"),
      
                                   (Matching.BBMatching,"BB")};
      
        10401
         strMatchingAlgorithm := getMatchingAlgorithmString();
      
        10401
         strMatchingAlgorithm := Util.getOptionOrDefault(ostrMatchingAlgorithm,strMatchingAlgorithm);
      
        10401
         matchingAlgorithm := selectMatchingAlgorithm(strMatchingAlgorithm,allMatchingAlgorithms);
      
        end getMatchingAlgorithm;
      
        protected function selectMatchingAlgorithm
      
        " function: selectMatchingAlgorithm"
      
          input String strMatchingAlgorithm;
      
          input list<tuple<Type_a,String>> inMatchingAlgorithms;
      
          output tuple<Type_a,String> outMatchingAlgorithm;
      
          replaceable type Type_a subtypeof Any;
      
        algorithm
      
          outMatchingAlgorithm:=
      
          matchcontinue inMatchingAlgorithms
      
            local
      
              String name,str;
      
              tuple<Type_a,String> method;
      
              list<tuple<Type_a,String>> methods;
      
            case (method as (_,name))::_
      
              guard
      
                stringEqual(strMatchingAlgorithm,name)
      
              then
      
                method;
      
            case _::methods
      
              algorithm
      
        134799
                method := selectMatchingAlgorithm(strMatchingAlgorithm,methods);
      
              then
      
                method;
      
            else
      
              algorithm
      
        ✗
                str := stringAppendList({"Selection of Matching Algorithm ",strMatchingAlgorithm," failed."});
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {str});
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end selectMatchingAlgorithm;
      
        // =============================================================================
      
        // Optimization module selection
      
        //
      
        // =============================================================================
      
        public function allPreOptimizationModules
      
          "This list contains all back end pre-optimization modules."
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> allPreOptimizationModules = {
      
            (BackendDAEUtil.introduceOutputRealDerivatives, "introduceOutputRealDerivatives"),
      
            (BackendDAEUtil.introduceOutputAliases, "introduceOutputAliases"),
      
            (DataReconciliation.newExtractionAlgorithm, "dataReconciliation"),
      
            (DataReconciliation.extractBoundaryCondition, "dataReconciliationBoundaryConditions"),
      
            (DataReconciliation.stateEstimation, "dataReconciliationStateEstimation"),
      
            (DynamicOptimization.createDynamicOptimization,"createDynamicOptimization"),
      
            (BackendInline.normalInlineFunction, "normalInlineFunction"),
      
            (EvaluateParameter.evaluateParameters, "evaluateParameters"),
      
            (RemoveSimpleEquations.removeVerySimpleEquations, "removeVerySimpleEquations"),
      
            (BackendDAEOptimize.simplifyIfEquations, "simplifyIfEquations"),
      
            (BackendDAEOptimize.expandDerOperator, "expandDerOperator"),
      
            (BackendDAEOptimize.removeLocalKnownVars, "removeLocalKnownVars"),
      
            (CommonSubExpression.wrapFunctionCalls, "wrapFunctionCalls"),
      
            (SynchronousFeatures.clockPartitioning, "clockPartitioning"),
      
            (IndexReduction.findStateOrder, "findStateOrder"),
      
            (BackendDAEOptimize.introduceDerAlias, "introduceDerAlias"),
      
            (DynamicOptimization.inputDerivativesForDynOpt, "inputDerivativesForDynOpt"), // only for dyn. opt.
      
            (BackendDAEOptimize.replaceEdgeChange, "replaceEdgeChange"),
      
            (InlineArrayEquations.inlineArrayEqn, "inlineArrayEqn"),
      
            (BackendDAEOptimize.sortEqnsVars, "sortEqnsVars"),
      
            (BackendDAEOptimize.removeEqualRHS, "removeEqualRHS"),
      
            (RemoveSimpleEquations.removeSimpleEquations, "removeSimpleEquations"),
      
            (CommonSubExpression.commonSubExpressionReplacement, "comSubExp"),
      
            (ResolveLoops.resolveLoops, "resolveLoops"),
      
            (EvaluateFunctions.evalFunctions, "evalFunc"),
      
            (FindZeroCrossings.encapsulateWhenConditions, "encapsulateWhenConditions"),
      
            // TODO: move the following modules to the correct position
      
            (BackendDAEOptimize.removeProtectedParameters, "removeProtectedParameters"),
      
            (BackendDAEOptimize.removeUnusedParameter, "removeUnusedParameter"),
      
            (BackendDAEOptimize.removeUnusedVariables, "removeUnusedVariables"),
      
            (BackendDAEOptimize.residualForm, "residualForm"),
      
            (BackendDAEOptimize.simplifyAllExpressions, "simplifyAllExpressions"),
      
            (BackendDAEOptimize.simplifyInStream, "simplifyInStream"),
      
            (BackendDump.dumpDAE, "dumpDAE"),
      
            (XMLDump.dumpDAEXML, "dumpDAEXML"),
      
            // This should indeed be at the end
      
            (BackendDAETransform.collapseArrayExpressions, "collapseArrayExpressions")
      
          };
      
        end allPreOptimizationModules;
      
        public function allPostOptimizationModules
      
          "This list contains all back end sim-optimization modules."
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> allPostOptimizationModules = {
      
            (BackendInline.lateInlineFunction, "lateInlineFunction"),
      
            (DynamicOptimization.simplifyConstraints, "simplifyConstraints"),
      
            (CommonSubExpression.wrapFunctionCalls, "wrapFunctionCalls"),
      
            (CommonSubExpression.cseBinary, "cseBinary"),
      
            (BackendDAEOptimize.replaceDerCalls, "replaceDerCalls"),
      
            (OnRelaxation.relaxSystem, "relaxSystem"),
      
            (InlineArrayEquations.inlineArrayEqn, "inlineArrayEqn"),
      
            (SymbolicJacobian.constantLinearSystem, "constantLinearSystem"),
      
            (BackendDAEOptimize.simplifysemiLinear, "simplifysemiLinear"),
      
            (ResolveLoops.solveLinearSystem, "solveLinearSystem"),
      
            (BackendDAEOptimize.addedScaledVars_states, "addScaledVars_states"),
      
            (BackendDAEOptimize.addedScaledVars_inputs, "addScaledVars_inputs"),
      
            (RemoveSimpleEquations.removeSimpleEquations, "removeSimpleEquations"),
      
            (BackendDAEOptimize.inlineFunctionInLoops, "forceInlineFunctionInLoops"), // before simplifyComplexFunction
      
            (BackendDAEOptimize.simplifyComplexFunction, "simplifyComplexFunction"),
      
            (ExpressionSolve.solveSimpleEquations, "solveSimpleEquations"),
      
            (ResolveLoops.reshuffling_post, "reshufflePost"),
      
            (DynamicOptimization.reduceDynamicOptimization, "reduceDynamicOptimization"), // before tearing
      
            (Tearing.tearingSystem, "tearingSystem"),
      
            (BackendDAEOptimize.simplifyLoops, "simplifyLoops"),
      
            (Tearing.recursiveTearing, "recursiveTearing"),
      
            (HpcOmEqSystems.partitionLinearTornSystem, "partlintornsystem"),
      
            (BackendDAEOptimize.countOperations, "countOperations"),
      
            (SymbolicJacobian.inputDerivativesUsed, "inputDerivativesUsed"),
      
            (DynamicOptimization.removeLoops, "extendDynamicOptimization"),
      
            (BackendDAEOptimize.addTimeAsState, "addTimeAsState"),
      
            (SymbolicJacobian.calculateStrongComponentJacobians, "calculateStrongComponentJacobians"),
      
            (SymbolicJacobian.calculateStateSetsJacobians, "calculateStateSetsJacobians"),
      
            (SymbolicJacobian.symbolicJacobian, "symbolicJacobian"),
      
            (SymbolicJacobian.generateSymbolicSensitivities, "generateSymbolicSensitivities"),
      
            (SymbolicJacobian.generateSymbolicLinearizationPast, "generateSymbolicLinearization"),
      
            (BackendDAEOptimize.removeConstants, "removeConstants"),
      
            (BackendDAEOptimize.simplifyTimeIndepFuncCalls, "simplifyTimeIndepFuncCalls"),
      
            (BackendDAEOptimize.simplifyAllExpressions, "simplifyAllExpressions"),
      
            (BackendDAEOptimize.hets, "hets"),
      
            (FindZeroCrossings.findZeroCrossings, "findZeroCrossings"),
      
            // TODO: move the following modules to the correct position
      
            (BackendDump.dumpComponentsGraphStr, "dumpComponentsGraphStr"),
      
            (BackendDump.dumpDAE, "dumpDAE"),
      
            (XMLDump.dumpDAEXML, "dumpDAEXML"),
      
            // This should indeed be at the end
      
            (BackendDAETransform.collapseArrayExpressions, "collapseArrayExpressions"),
      
            // DAEmode modules
      
            (DAEMode.createDAEmodeBDAE, "createDAEmodeBDAE"),
      
            (SymbolicJacobian.symbolicJacobianDAE, "symbolicJacobianDAE"),
      
            (BackendDAEUtil.setEvaluationStage, "setEvaluationStage")
      
          };
      
        end allPostOptimizationModules;
      
        protected function allInitOptimizationModules
      
          "This list contains all back end init-optimization modules."
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> allInitOptimizationModules = {
      
            (Initialization.replaceHomotopyWithSimplified, "replaceHomotopyWithSimplified"),
      
            (InlineArrayEquations.inlineArrayEqn, "inlineArrayEqn"),
      
            (SymbolicJacobian.constantLinearSystem, "constantLinearSystem"),
      
            (BackendDAEOptimize.inlineHomotopy, "inlineHomotopy"),
      
            (BackendDAEOptimize.inlineFunctionInLoops, "forceInlineFunctionInLoops"), // before simplifyComplexFunction
      
            (BackendDAEOptimize.simplifyComplexFunction, "simplifyComplexFunction"),
      
            (CommonSubExpression.wrapFunctionCalls, "wrapFunctionCalls"),
      
            (DynamicOptimization.reduceDynamicOptimization, "reduceDynamicOptimization"), // before tearing
      
            (Tearing.tearingSystem, "tearingSystem"),
      
            (BackendDAEOptimize.simplifyLoops, "simplifyLoops"),
      
            (Tearing.recursiveTearing, "recursiveTearing"),
      
            (ExpressionSolve.solveSimpleEquations, "solveSimpleEquations"),
      
            (BackendDAEOptimize.generateHomotopyComponents, "generateHomotopyComponents"), // after tearing, after solveSimpleEquations, before calculateStrongComponentJacobians
      
            (SymbolicJacobian.calculateStrongComponentJacobians, "calculateStrongComponentJacobians"),
      
            (BackendDAEOptimize.simplifyAllExpressions, "simplifyAllExpressions"),
      
            (SymbolicJacobian.inputDerivativesUsed, "inputDerivativesUsed"),
      
            (DynamicOptimization.removeLoops, "extendDynamicOptimization"),
      
            // This should indeed be at the end
      
            (BackendDAETransform.collapseArrayExpressions, "collapseArrayExpressions")
      
          };
      
        end allInitOptimizationModules;
      
        public function getPreOptModulesString
      
          output list<String> strPreOptModules;
      
        algorithm
      
        1176
          strPreOptModules := Config.getPreOptModules();
      
        end getPreOptModulesString;
      
        public function isDataReconciliationEnabled
      
          "Returns true if one of the data reconciliation pre-optimization modules is
      
           enabled or the uncertainty extraction (modelEquationsUC) is running. The
      
           uncertain attribute is only meaningful for these and must not influence a
      
           plain simulation."
      
          output Boolean enabled;
      
        protected
      
          constant list<String> drModules = {"dataReconciliation", "dataReconciliationBoundaryConditions", "dataReconciliationStateEstimation"};
      
        algorithm
      
          3/4✗ Branch 1 not taken.
✓ Branch 2 taken 78 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 76 times.

        78
          if isSome(getGlobalRoot(Global.uncertaintyExtraction)) then
      
            enabled := true;
      
        76
            return;
      
          end if;
      
          2/2✓ Branch 3 taken 28 times.
✓ Branch 4 taken 2 times.

        30
          for m in listAppend(Flags.getConfigStringList(Flags.PRE_OPT_MODULES_ADD), getPreOptModulesString()) loop
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.

        28
            if listMember(m, drModules) then
      
              enabled := true;
      
        ✗
              return;
      
            end if;
      
          end for;
      
          enabled := false;
      
        end isDataReconciliationEnabled;
      
        protected function deprecatedDebugFlag
      
          input Flags.DebugFlag inFlag;
      
          input list<String> inModuleList;
      
          input String inModule;
      
          input String inPhase;
      
          output list<String> outModuleList = inModuleList;
      
        algorithm
      
          1/2✓ Branch 1 taken 1077 times.
✗ Branch 2 not taken.

        1077
          if Flags.isSet(inFlag) then
      
            outModuleList := inModule::inModuleList;
      
        ✗
            Error.addCompilerWarning("Deprecated debug flag -d=" + FlagsUtil.debugFlagName(inFlag) + " detected. Use --" + inPhase + "=" + inModule + " instead.");
      
          end if;
      
        end deprecatedDebugFlag;
      
        protected function deprecatedConfigFlag
      
          input Flags.ConfigFlag inFlag;
      
          input list<String> inModuleList;
      
          input String inModule;
      
          input String inPhase;
      
          output list<String> outModuleList = inModuleList;
      
        algorithm
      
        ✗
          if Flags.getConfigBool(inFlag) then
      
            outModuleList := inModule::inModuleList;
      
        ✗
            Error.addCompilerWarning("Deprecated flag --" + FlagsUtil.configFlagName(inFlag) + " detected. Use --" + inPhase + "=" + inModule + " instead.");
      
          end if;
      
        end deprecatedConfigFlag;
      
        public function getPreOptModules
      
          input Option<list<String>> inPreOptModules;
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> outPreOptModules;
      
        protected
      
          list<String> preOptModules;
      
          list<String> enabledModules = Flags.getConfigStringList(Flags.PRE_OPT_MODULES_ADD);
      
          list<String> disabledModules = Flags.getConfigStringList(Flags.PRE_OPT_MODULES_SUB);
      
        algorithm
      
        1091
          preOptModules := getPreOptModulesString();
      
        1091
          preOptModules := Util.getOptionOrDefault(inPreOptModules, preOptModules);
      
          3/4✗ Branch 1 not taken.
✓ Branch 2 taken 1091 times.
✓ Branch 5 taken 16 times.
✓ Branch 6 taken 1075 times.

        1091
          if isSome(getGlobalRoot(Global.isInStream)) then
      
            enabledModules := "simplifyInStream"::enabledModules;
      
          end if;
      
          2/2✓ Branch 1 taken 1077 times.
✓ Branch 2 taken 14 times.

        1091
          if Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) then
      
            // handle special flags, which enable modules
      
        1077
            enabledModules := deprecatedDebugFlag(Flags.SORT_EQNS_AND_VARS, enabledModules, "sortEqnsVars", "preOptModules+");
      
          3/4✓ Branch 1 taken 1043 times.
✓ Branch 2 taken 34 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1043 times.

        1077
            if Config.acceptOptimicaGrammar() or Flags.getConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM) then
      
              enabledModules := "inputDerivativesForDynOpt"::enabledModules;
      
              enabledModules := "createDynamicOptimization"::enabledModules;
      
            end if;
      
            // handle special flags, which disable modules
      
          2/8✗ Branch 1 not taken.
✓ Branch 2 taken 1077 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1077 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.

        1077
            if Flags.getConfigString(Flags.REMOVE_SIMPLE_EQUATIONS) == "causal" or
      
               Flags.getConfigString(Flags.REMOVE_SIMPLE_EQUATIONS) == "none" then
      
              disabledModules := "removeSimpleEquations"::disabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1074 times.

        1077
            if not Flags.isSet(Flags.NF_SCALARIZE) then
      
              disabledModules := "inlineArrayEqn"::disabledModules;
      
            end if;
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1077 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1091
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(enabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --preOptModules+=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1077 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1091
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(disabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --postOptModules-=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
        1091
          outPreOptModules := selectOptModules(preOptModules, enabledModules, disabledModules, allPreOptimizationModules());
      
        end getPreOptModules;
      
        public function getPostOptModulesString
      
          output list<String> strpostOptModules;
      
        algorithm
      
        1089
          strpostOptModules := Config.getPostOptModules();
      
        end getPostOptModulesString;
      
        public function getPostOptModules
      
          input Option<list<String>> inPostOptModules;
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> outPostOptModules;
      
        protected
      
          list<String> postOptModules;
      
          list<String> enabledModules = Flags.getConfigStringList(Flags.POST_OPT_MODULES_ADD);
      
          list<String> disabledModules = Flags.getConfigStringList(Flags.POST_OPT_MODULES_SUB);
      
        algorithm
      
        1089
          postOptModules := getPostOptModulesString();
      
        1089
          postOptModules := Util.getOptionOrDefault(inPostOptModules, postOptModules);
      
          2/2✓ Branch 1 taken 1075 times.
✓ Branch 2 taken 14 times.

        1089
          if Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) then
      
            // handle special flags, which enable modules
      
          2/2✓ Branch 1 taken 34 times.
✓ Branch 2 taken 1041 times.

        1075
            if Flags.getConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM) then
      
              enabledModules := "simplifyConstraints"::enabledModules;
      
            end if;
      
          3/4✓ Branch 1 taken 1068 times.
✓ Branch 2 taken 7 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1068 times.

        1075
            if not Flags.getConfigString(Flags.LOOP2CON) == "none" then
      
              enabledModules := "extendDynamicOptimization"::enabledModules;
      
            end if;
      
          4/6✓ Branch 1 taken 1024 times.
✓ Branch 2 taken 51 times.
✓ Branch 4 taken 1024 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 1024 times.

        1075
            if Flags.getConfigBool(Flags.GENERATE_SYMBOLIC_LINEARIZATION)  or  Config.acceptOptimicaGrammar() or Flags.getConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM) then
      
              enabledModules := "generateSymbolicLinearization"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1071 times.

        1075
            if Flags.getConfigInt(Flags.SIMPLIFY_LOOPS) > 0 then
      
              enabledModules := "simplifyLoops"::enabledModules;
      
            end if;
      
          2/4✓ Branch 1 taken 1075 times.
✗ Branch 2 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 1075 times.

        1075
            if Flags.getConfigString(Flags.HETS) <> "none" then
      
              enabledModules := "hets"::enabledModules;
      
            end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1075 times.

        1075
            if Flags.isSet(Flags.COUNT_OPERATIONS) then
      
              enabledModules := "countOperations"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1073 times.

        1075
            if 1 < Flags.getConfigInt(Flags.MAX_SIZE_FOR_SOLVE_LINIEAR_SYSTEM) then
      
              enabledModules := "solveLinearSystem"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1074 times.

        1075
            if Flags.isSet(Flags.RESHUFFLE_POST) then
      
              enabledModules := "reshufflePost"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 8 times.
✓ Branch 2 taken 1067 times.

        1075
            if Flags.getConfigInt(Flags.RTEARING) > 0 then
      
              enabledModules := "recursiveTearing"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1074 times.

        1075
            if Flags.getConfigInt(Flags.PARTLINTORN) > 0 then
      
              enabledModules := "partlintornsystem"::enabledModules;
      
            end if;
      
          3/12✗ Branch 1 not taken.
✓ Branch 2 taken 1075 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 1075 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 15 not taken.
✓ Branch 16 taken 1075 times.
✗ Branch 19 not taken.
✗ Branch 20 not taken.

        1075
            if Flags.getConfigString(Flags.REMOVE_SIMPLE_EQUATIONS) == "none" or
      
               Flags.getConfigString(Flags.REMOVE_SIMPLE_EQUATIONS) == "fastAcausal" or
      
               Flags.getConfigString(Flags.REMOVE_SIMPLE_EQUATIONS) == "allAcausal" then
      
              disabledModules := "removeSimpleEquations"::disabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1072 times.

        1075
            if not Flags.isSet(Flags.NF_SCALARIZE) then
      
              disabledModules := "inlineArrayEqn"::disabledModules;
      
            end if;
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1075 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1089
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(enabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --postOptModules+=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1075 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1089
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(disabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --postOptModules-=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
        1089
          outPostOptModules := selectOptModules(postOptModules, enabledModules, disabledModules, allPostOptimizationModules());
      
        end getPostOptModules;
      
        public function getInitOptModules
      
          input Option<list<String>> inInitOptModules;
      
          input list<String> inEnabledModules = {};
      
          input list<String> inDisabledModules = {};
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> outInitOptModules;
      
        protected
      
          list<String> initOptModules;
      
          list<String> enabledModules = Flags.getConfigStringList(Flags.INIT_OPT_MODULES_ADD);
      
          list<String> disabledModules = Flags.getConfigStringList(Flags.INIT_OPT_MODULES_SUB);
      
        algorithm
      
        1120
          initOptModules := Config.getInitOptModules();
      
        1120
          initOptModules := Util.getOptionOrDefault(inInitOptModules, initOptModules);
      
          2/2✓ Branch 1 taken 1106 times.
✓ Branch 2 taken 14 times.

        1120
          if Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) then
      
            // handle special flags, which enable modules
      
          2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 1102 times.

        1106
            if Flags.getConfigInt(Flags.SIMPLIFY_LOOPS) > 0 then
      
              enabledModules := "simplifyLoops"::enabledModules;
      
            end if;
      
          2/2✓ Branch 1 taken 9 times.
✓ Branch 2 taken 1097 times.

        1106
            if Flags.getConfigInt(Flags.RTEARING) > 0 then
      
              enabledModules := "recursiveTearing"::enabledModules;
      
            end if;
      
            // handle special flags, which disable modules
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1106 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1120
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(enabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --initOptModules+=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
          3/4✓ Branch 1 taken 14 times.
✓ Branch 2 taken 1106 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 14 times.

        1120
          if not Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING) and not listEmpty(disabledModules) then
      
        ✗
            Error.addCompilerError("It's not possible to combine following flags: --initOptModules-=... and --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false");
      
        ✗
            fail();
      
          end if;
      
        1120
          outInitOptModules := selectOptModules(initOptModules, enabledModules, disabledModules, allInitOptimizationModules());
      
        1120
          initOptModules := List.map(outInitOptModules, Util.tuple22);
      
        1120
          outInitOptModules := selectOptModules(initOptModules, inEnabledModules, inDisabledModules, allInitOptimizationModules());
      
        end getInitOptModules;
      
        protected function selectOptModules
      
          input list<String> inStrOptModules;
      
          input list<String> inEnabledModules = {};
      
          input list<String> inDisabledModules = {};
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> inOptModules;
      
          output list<tuple<BackendDAEFunc.optimizationModule, String>> outOptModules = {};
      
        protected
      
          Boolean forceOrdering = Flags.getConfigBool(Flags.DEFAULT_OPT_MODULES_ORDERING);
      
          String name;
      
          Integer numModules = listLength(inOptModules);
      
          array<Boolean> activeModules = arrayCreate(numModules, false);
      
          Integer index;
      
          Integer maxIndex = -1;
      
        algorithm
      
          2/2✓ Branch 0 taken 7866 times.
✓ Branch 1 taken 62 times.

        7928
          if forceOrdering then
      
          2/2✓ Branch 0 taken 66962 times.
✓ Branch 1 taken 7866 times.

        74828
            for name in inStrOptModules loop
      
          2/2✓ Branch 1 taken 66962 times.
✓ Branch 2 taken 66962 times.

        133924
              for index in getModuleIndexes(name, inOptModules) loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 66962 times.

        66962
                if index < maxIndex then
      
        ✗
                  Error.addCompilerWarning("Specified ordering will be ignored. Use --" + FlagsUtil.configFlagName(Flags.DEFAULT_OPT_MODULES_ORDERING) + "=false to override module ordering.");
      
                  maxIndex := numModules;
      
                else
      
                  maxIndex := intMax(maxIndex, index);
      
                end if;
      
        66962
                activeModules[index] := true;
      
              end for;
      
            end for;
      
          2/2✓ Branch 0 taken 272 times.
✓ Branch 1 taken 7866 times.

        8138
            for name in inEnabledModules loop
      
          2/2✓ Branch 2 taken 272 times.
✓ Branch 3 taken 272 times.

        544
              for index in getModuleIndexes(name, inOptModules) loop
      
        272
                activeModules[index] := true;
      
              end for;
      
            end for;
      
          2/2✓ Branch 0 taken 2164 times.
✓ Branch 1 taken 7866 times.

        10030
            for name in inDisabledModules loop
      
          2/2✓ Branch 2 taken 2164 times.
✓ Branch 3 taken 2164 times.

        4328
              for index in getModuleIndexes(name, inOptModules) loop
      
        2164
                activeModules[index] := false;
      
              end for;
      
            end for;
      
          1/2✓ Branch 0 taken 7866 times.
✗ Branch 1 not taken.

        268180
            for i in 1:numModules loop
      
          2/2✓ Branch 1 taken 67189 times.
✓ Branch 2 taken 193125 times.

        260314
              if activeModules[i] then
      
        67189
                outOptModules := listGet(inOptModules, i)::outOptModules;
      
              end if;
      
            end for;
      
          else
      
          2/2✓ Branch 0 taken 257 times.
✓ Branch 1 taken 62 times.

        319
            for name in inStrOptModules loop
      
        257
              outOptModules := selectOptModules1(name, inOptModules)::outOptModules;
      
            end for;
      
          end if;
      
        7928
          outOptModules := listReverse(outOptModules);
      
        end selectOptModules;
      
        protected function getModuleIndexes
      
          input String inModuleName;
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> inModuleList;
      
          output list<Integer> outIndexes = {};
      
        protected
      
          String name;
      
          Integer index=1;
      
        algorithm
      
          2/2✓ Branch 0 taken 2433662 times.
✓ Branch 1 taken 69398 times.

        2503060
          for module in inModuleList loop
      
        2433662
            (_, name) := module;
      
          4/4✓ Branch 0 taken 181735 times.
✓ Branch 1 taken 2251927 times.
✓ Branch 3 taken 69398 times.
✓ Branch 4 taken 112337 times.

        2433662
            if stringEqual(inModuleName, name) then
      
              outIndexes := index::outIndexes;
      
            end if;
      
        2433662
            index := index+1;
      
          end for;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69398 times.

        69398
          if listEmpty(outIndexes) then
      
        ✗
            Error.addCompilerError("'" + inModuleName + "' is not a valid optimization module. Please check the flags carefully.");
      
        ✗
            fail();
      
          end if;
      
        end getModuleIndexes;
      
        protected function selectOptModules1
      
          input String strOptModule;
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> inOptModules;
      
          output tuple<BackendDAEFunc.optimizationModule, String> outOptModule;
      
        algorithm
      
          outOptModule := match inOptModules
      
            local
      
              String name;
      
              tuple<BackendDAEFunc.optimizationModule, String> module;
      
              list<tuple<BackendDAEFunc.optimizationModule, String>> rest;
      
            case (module as (_, name))::_ guard(stringEqual(name, strOptModule))
      
            then module;
      
            case (_, name)::rest guard(not stringEqual(name, strOptModule))
      
        3616
            then selectOptModules1(strOptModule, rest);
      
            else algorithm
      
        ✗
              Error.addInternalError("Selection of optimization module " + strOptModule + " failed.", sourceInfo());
      
        ✗
            then fail();
      
          end match;
      
        end selectOptModules1;
      
        public function isInitOptModuleActivated " returns true if given initOptModule is activated
      
          author: ptaeuber"
      
          input String initOptModule;
      
          input list<tuple<BackendDAEFunc.optimizationModule, String>> activatedInitOptModules = {};
      
          output Boolean isActivated = false;
      
        protected
      
          list<tuple<BackendDAEFunc.optimizationModule, String>> modules = activatedInitOptModules;
      
          String s;
      
        algorithm
      
        ✗
          if listEmpty(modules) then
      
        ✗
            modules := getInitOptModules(NONE());
      
          end if;
      
        ✗
          for module in modules loop
      
        ✗
            (_, s) := module;
      
        ✗
            if stringEqual(s, initOptModule) then
      
              isActivated := true;
      
        ✗
              return;
      
            end if;
      
          end for;
      
        end isInitOptModuleActivated;
      
        /*************************************************
      
         * traverse BackendDAE equation systems
      
         ************************************************/
      
        public function mapEqSystem1<A>
      
          "Helper to map a preopt module over each equation system"
      
          input BackendDAE.BackendDAE dae;
      
          input Function func;
      
          input A a;
      
          output BackendDAE.BackendDAE odae;
      
          partial function Function
      
            input BackendDAE.EqSystem syst;
      
            input A a;
      
            input BackendDAE.Shared shared;
      
            output BackendDAE.EqSystem osyst;
      
            output BackendDAE.Shared oshared;
      
          end Function;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        2233
          BackendDAE.DAE(systs, shared) := dae;
      
        2233
          (systs, shared) := List.map1Fold(systs, func, a, shared);
      
          // Filter out empty systems
      
        2233
          (systs, shared) := filterEmptySystems(systs, shared);
      
        2233
          odae := BackendDAE.DAE(systs, shared);
      
        end mapEqSystem1;
      
        public function mapEqSystemAndFold<B>
      
          "Helper to map a preopt module over each equation system"
      
          input BackendDAE.BackendDAE inDAE;
      
          input Function inFunc;
      
          input B initialExtra;
      
          output BackendDAE.BackendDAE outDAE;
      
          output B outExtra;
      
          partial function Function
      
            input BackendDAE.EqSystem inSyst;
      
            input BackendDAE.Shared inShared;
      
            input B inExtra;
      
            output BackendDAE.EqSystem outSyst;
      
            output BackendDAE.Shared outShared;
      
            output B outExtra;
      
          end Function;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        21777
          BackendDAE.DAE(systs, shared) := inDAE;
      
        21777
          (systs, shared, outExtra) := List.mapFold2(systs, inFunc, shared, initialExtra);
      
          // Filter out empty systems
      
        21777
          (systs, shared) := filterEmptySystems(systs, shared);
      
        21777
          outDAE := BackendDAE.DAE(systs, shared);
      
        end mapEqSystemAndFold;
      
        public function foldEqSystem
      
          "Helper to map a preopt module over each equation system"
      
          input BackendDAE.BackendDAE dae;
      
          input Function func;
      
          input B initialExtra;
      
          output B extra;
      
          partial function Function
      
            input BackendDAE.EqSystem syst;
      
            input BackendDAE.Shared shared;
      
            input B fold;
      
            output B ofold;
      
          end Function;
      
          replaceable type B subtypeof Any;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        10483
          BackendDAE.DAE(systs, shared) := dae;
      
        10483
          extra := List.fold1(systs,func,shared,initialExtra);
      
          // Filter out empty systems
      
        10483
          (_, shared) := filterEmptySystems(systs, shared);
      
        end foldEqSystem;
      
        public function mapEqSystem
      
          "Helper to map a preopt module over each equation system"
      
          input BackendDAE.BackendDAE inDAE;
      
          input Function inFunc;
      
          output BackendDAE.BackendDAE outDAE;
      
          partial function Function
      
            input BackendDAE.EqSystem syst;
      
            input BackendDAE.Shared shared;
      
            output BackendDAE.EqSystem osyst;
      
            output BackendDAE.Shared oshared;
      
          end Function;
      
        protected
      
          list<BackendDAE.EqSystem> systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        20344
          BackendDAE.DAE(systs, shared) := inDAE;
      
        20344
          (systs, shared) := List.mapFold(systs, inFunc, shared);
      
          // Filter out empty systems
      
        20343
          (systs, shared) := filterEmptySystems(systs, shared);
      
        20343
          outDAE := BackendDAE.DAE(systs, shared);
      
        end mapEqSystem;
      
        public function nonEmptySystem
      
          input BackendDAE.EqSystem syst;
      
          output Boolean nonEmpty;
      
        algorithm
      
          4/4✓ Branch 1 taken 852 times.
✓ Branch 2 taken 47540 times.
✓ Branch 4 taken 829 times.
✓ Branch 5 taken 23 times.

        48392
          nonEmpty := BackendVariable.varsSize(syst.orderedVars) <> 0 or BackendEquation.getNumberOfEquations(syst.removedEqs) <> 0;
      
        end nonEmptySystem;
      
        protected function filterEmptySystems
      
          "Filter out equation systems leaving at least one behind"
      
          input BackendDAE.EqSystems inSysts;
      
          input BackendDAE.Shared inShared;
      
          output BackendDAE.EqSystems outSysts = {};
      
          output BackendDAE.Shared outShared = inShared;
      
        protected
      
          list<BackendDAE.Equation> reqns = {};
      
        algorithm
      
          2/2✓ Branch 0 taken 898767 times.
✓ Branch 1 taken 115450 times.

        1014217
          for e in inSysts loop
      
        898767
            (reqns, outSysts) := filterEmptySystem(e, reqns, outSysts);
      
          end for;
      
          2/2✓ Branch 0 taken 4724 times.
✓ Branch 1 taken 110726 times.

        115450
          if listEmpty(outSysts) then
      
        9448
            outSysts := {BackendDAEUtil.createEqSystem(BackendVariable.emptyVars(), BackendEquation.emptyEqns())};
      
          else
      
        110726
            outSysts := Dangerous.listReverseInPlace(outSysts);
      
          end if;
      
          1/2✓ Branch 1 taken 115450 times.
✗ Branch 2 not taken.

        115450
          outShared.removedEqs := BackendEquation.addList(reqns, outShared.removedEqs);
      
        end filterEmptySystems;
      
        protected function filterEmptySystem
      
          input BackendDAE.EqSystem inSyst;
      
          input output list<BackendDAE.Equation> reqs;
      
          input output BackendDAE.EqSystems systs;
      
        algorithm
      
          3/6✓ Branch 1 taken 23961 times.
✓ Branch 2 taken 874806 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 23961 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.

        898767
          if BackendVariable.varsSize(inSyst.orderedVars) <> 0 or
      
             (isClockedSyst(inSyst) and BackendEquation.getNumberOfEquations(inSyst.removedEqs) <> 0) then
      
        874806
            systs := inSyst::systs;
      
          else
      
        23961
             reqs := listAppend(BackendEquation.equationList(inSyst.removedEqs), reqs);
      
          end if;
      
        end filterEmptySystem;
      
        public function getAllVarLst "retrieve all variables of the dae by collecting them from each equation system and combining with known vars"
      
          input BackendDAE.BackendDAE dae;
      
          output list<BackendDAE.Var> varLst;
      
        protected
      
          BackendDAE.EqSystems eqs;
      
          BackendDAE.Variables globalKnownVars;
      
        algorithm
      
        ✗
          BackendDAE.DAE(eqs=eqs,shared = BackendDAE.SHARED(globalKnownVars=globalKnownVars)) := dae;
      
        ✗
          varLst := List.flatten(List.map(globalKnownVars::List.map(eqs, BackendVariable.daeVars), BackendVariable.varList));
      
        end getAllVarLst;
      
        public function isClockedSyst
      
          input BackendDAE.EqSystem inSyst;
      
          output Boolean out;
      
        algorithm
      
          out := match inSyst
      
            case BackendDAE.EQSYSTEM(partitionKind=BackendDAE.CLOCKED_PARTITION()) then true;
      
            else false;
      
          end match;
      
        end isClockedSyst;
      
        public function getAlgorithms
      
          input BackendDAE.BackendDAE dae;
      
          output array<DAE.Algorithm> algs;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          list<DAE.Algorithm> alglst;
      
        algorithm
      
        ✗
          BackendDAE.DAE(eqs=systs) := dae;
      
        ✗
          alglst := List.fold(systs,collectAlgorithmsFromEqSystem,{});
      
        ✗
          algs := listArray(alglst);
      
        end getAlgorithms;
      
        protected function collectAlgorithmsFromEqSystem
      
          input BackendDAE.EqSystem syst;
      
          input list<DAE.Algorithm> alglst;
      
          output list<DAE.Algorithm> oalglst;
      
        protected
      
          BackendDAE.EquationArray eqns;
      
        algorithm
      
        ✗
          BackendDAE.EQSYSTEM(orderedEqs=eqns) := syst;
      
        ✗
          oalglst := BackendEquation.traverseEquationArray(eqns,collectAlgorithms,alglst);
      
        end collectAlgorithmsFromEqSystem;
      
        protected function collectAlgorithms
      
          input BackendDAE.Equation inEq;
      
          input list<DAE.Algorithm> inAlgs;
      
          output BackendDAE.Equation outEq;
      
          output list<DAE.Algorithm> algs;
      
        algorithm
      
          (outEq,algs) := match (inEq,inAlgs)
      
            local
      
              DAE.Algorithm alg;
      
            case (BackendDAE.ALGORITHM(alg=alg),algs)
      
              then (inEq,alg::algs);
      
            else (inEq,inAlgs);
      
          end match;
      
        end collectAlgorithms;
      
        // =============================================================================
      
        // section for getConditionList
      
        //
      
        // =============================================================================
      
        public function getConditionList "author: lochel
      
          This function extracts all when-conditions. A when-condition can only be a
      
          ComponentRef or initial()-call. If one condition is equal to >initial()<, the
      
          second output becomes true."
      
          input DAE.Exp inCondition;
      
          output list<DAE.ComponentRef> outConditionVarList;
      
          output Boolean outInitialCall;
      
        algorithm
      
          (outConditionVarList, outInitialCall) := match inCondition
      
            local
      
              list<DAE.Exp> conditionList;
      
              list<DAE.ComponentRef> conditionVarList;
      
              Boolean initialCall;
      
            case DAE.ARRAY(array=conditionList)
      
              algorithm
      
        197
                (conditionVarList, initialCall) := getConditionList1(conditionList, {}, false);
      
              then (conditionVarList, initialCall);
      
            else
      
              algorithm
      
        515
                (conditionVarList, initialCall) := getConditionList1({inCondition}, {}, false);
      
              then (conditionVarList, initialCall);
      
          end match;
      
        end getConditionList;
      
        protected function getConditionList1 "author: lochel"
      
          input list<DAE.Exp> inConditionList;
      
          input list<DAE.ComponentRef> inConditionVarList;
      
          input Boolean inInitialCall;
      
          output list<DAE.ComponentRef> outConditionVarList;
      
          output Boolean outInitialCall;
      
        algorithm
      
          (outConditionVarList, outInitialCall) := match inConditionList
      
            local
      
              list<DAE.Exp> conditionList;
      
              list<DAE.ComponentRef> conditionVarList;
      
              Boolean initialCall;
      
              DAE.ComponentRef componentRef;
      
              DAE.Exp exp;
      
            case {}
      
            then (inConditionVarList, inInitialCall);
      
            // filter constant conditions
      
            case exp::conditionList guard(Expression.isConst(exp)) algorithm
      
        83
              (conditionVarList, initialCall) := getConditionList1(conditionList, inConditionVarList, inInitialCall);
      
            then (conditionVarList, initialCall);
      
            case DAE.CALL(path=Absyn.IDENT(name="initial"))::conditionList algorithm
      
        29
              (conditionVarList, initialCall) := getConditionList1(conditionList, inConditionVarList, true);
      
            then (conditionVarList, initialCall);
      
            case DAE.CREF(componentRef=componentRef)::conditionList algorithm
      
        826
              (conditionVarList, initialCall) := getConditionList1(conditionList, componentRef::inConditionVarList, inInitialCall);
      
            then (conditionVarList, initialCall);
      
            case exp::_ algorithm
      
        ✗
              Error.addInternalError("function getConditionList1 failed for " + ExpressionBasics.printExpStr(exp), sourceInfo());
      
        ✗
            then fail();
      
          end match;
      
        end getConditionList1;
      
        public function isArrayComp"outputs true if the strongComponent is an arrayEquation"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isArray;
      
        algorithm
      
          isArray := match comp
      
            case BackendDAE.SINGLEARRAY()
      
              then true;
      
          else false;
      
          end match;
      
        end isArrayComp;
      
        public function isWhenComp"outputs true if the strongComponent is a whenEquation"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.SINGLEWHENEQUATION()
      
              then true;
      
          else false;
      
          end match;
      
        end isWhenComp;
      
        public function isSingleEquationComp "outputs true if the strongComponent is a singleEquation"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.SINGLEEQUATION()
      
              then true;
      
          else false;
      
          end match;
      
        end isSingleEquationComp;
      
        public function isLinearEqSystemComp "outputs true if the strongComponent is a linear equationsystem"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.EQUATIONSYSTEM(jacType = BackendDAE.JAC_LINEAR())
      
              then true;
      
          else false;
      
          end match;
      
        end isLinearEqSystemComp;
      
        public function isNonLinearEqSystemComp "outputs true if the strongComponent is a nonlinear equationsystem"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.EQUATIONSYSTEM(jacType = BackendDAE.JAC_NONLINEAR())
      
              then true;
      
          else false;
      
          end match;
      
        end isNonLinearEqSystemComp;
      
        public function isLinearTornSystemComp "outputs true if the strongComponent is a linear torn system"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.TORNSYSTEM(linear=true)
      
              then true;
      
          else false;
      
          end match;
      
        end isLinearTornSystemComp;
      
        public function isNonLinearTornSystemComp "outputs true if the strongComponent is a nonlinear torn system"
      
          input BackendDAE.StrongComponent comp;
      
          output Boolean isWhen;
      
        algorithm
      
          isWhen := match comp
      
            case BackendDAE.TORNSYSTEM(linear=false)
      
              then true;
      
          else false;
      
          end match;
      
        end isNonLinearTornSystemComp;
      
        public function extendRange
      
          input DAE.Exp inRangeExp;
      
          input BackendDAE.Variables inKnVariables;
      
          output list<DAE.Exp> outExpLst = {};
      
        protected
      
          DAE.Exp start, step, stop;
      
          Option<DAE.Exp> ostep;
      
          DAE.Type ty;
      
        algorithm
      
          try
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 106 times.

        107
            DAE.RANGE(ty = ty, start = start, step = ostep, stop = stop) := inRangeExp;
      
        106
            start := evalExp(start, inKnVariables);
      
        106
            stop := evalExp(stop, inKnVariables);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 101 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 101 times.

        101
            if isSome(ostep) then
      
        ✗
              SOME(step) := ostep;
      
        ✗
              ostep := SOME(evalExp(step, inKnVariables));
      
            end if;
      
        101
            outExpLst := Expression.expandRange(DAE.RANGE(ty, start, ostep, stop));
      
          else
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.

        6
            if Flags.isSet(Flags.FAILTRACE) then
      
        ✗
              Debug.trace("BackendDAECreate.extendRange failed. Maybe some ZeroCrossing are not supported\n");
      
            end if;
      
          end try;
      
        end extendRange;
      
        public function evalExp
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inKnVariables;
      
          output DAE.Exp outExp;
      
        algorithm
      
          outExp := match inExp
      
            local
      
              DAE.Exp e, e1, e2;
      
            case DAE.CREF()
      
              algorithm
      
          0/6✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        5
                ((BackendDAE.VAR(bindExp = SOME(e)) :: _), _) :=
      
                  BackendVariable.getVar(inExp.componentRef, inKnVariables);
      
              then
      
                e;
      
            case DAE.BINARY(operator = DAE.ADD(DAE.T_INTEGER()))
      
              algorithm
      
        ✗
                e1 := evalExp(inExp.exp1, inKnVariables);
      
        ✗
                e2 := evalExp(inExp.exp2, inKnVariables);
      
        ✗
              then
      
                DAE.ICONST(Expression.expInt(e1) + Expression.expInt(e2));
      
            case DAE.BINARY(operator = DAE.SUB(DAE.T_INTEGER()))
      
              algorithm
      
        ✗
                e1 := evalExp(inExp.exp1, inKnVariables);
      
        ✗
                e2 := evalExp(inExp.exp2, inKnVariables);
      
        ✗
              then
      
                DAE.ICONST(Expression.expInt(e1) - Expression.expInt(e2));
      
            else inExp;
      
          end match;
      
        end evalExp;
      
        public function expInt "returns the int value of an expression"
      
          input DAE.Exp inExp;
      
          input BackendDAE.Variables inKnVariables;
      
          output Integer i;
      
        algorithm
      
          i := match inExp
      
            local
      
              Integer i1, i2;
      
              DAE.ComponentRef cr;
      
              DAE.Exp e, e1, e2;
      
            case DAE.ICONST(integer=i2)
      
            then i2;
      
            case DAE.ENUM_LITERAL(index=i2)
      
            then i2;
      
            case DAE.CREF(componentRef=cr) algorithm
      
        ✗
              ((BackendDAE.VAR(bindExp=SOME(e)):: _), _) := BackendVariable.getVar(cr, inKnVariables);
      
        ✗
              i2 := expInt(e, inKnVariables);
      
            then i2;
      
            case DAE.BINARY(exp1=e1, operator=DAE.ADD(DAE.T_INTEGER()), exp2=e2) algorithm
      
        ✗
              i1 := expInt(e1, inKnVariables);
      
              i2 := expInt(e2, inKnVariables);
      
              i := i1 + i2;
      
            then i;
      
            case DAE.BINARY(exp1=e1, operator=DAE.SUB(DAE.T_INTEGER()), exp2=e2) algorithm
      
        ✗
              i1 := expInt(e1, inKnVariables);
      
              i2 := expInt(e2, inKnVariables);
      
              i := i1 - i2;
      
            then i;
      
          end match;
      
        end expInt;
      
        public function createEqSystem
      
          input BackendDAE.Variables inVars;
      
          input BackendDAE.EquationArray inEqs = BackendEquation.emptyEqns();
      
          input BackendDAE.StateSets inStateSets = {};
      
          input BackendDAE.BaseClockPartitionKind inPartitionKind = BackendDAE.UNKNOWN_PARTITION();
      
          input BackendDAE.EquationArray removedEqs = BackendEquation.emptyEqns();
      
          output BackendDAE.EqSystem outSyst;
      
        algorithm
      
        155690
          outSyst := BackendDAE.EQSYSTEM( inVars, inEqs, NONE(), NONE(), NONE(), BackendDAE.NO_MATCHING(),
      
                                          inStateSets, inPartitionKind, removedEqs );
      
        end createEqSystem;
      
        public function createEmptyShared
      
          input BackendDAE.BackendDAEType backendDAEType;
      
          input BackendDAE.ExtraInfo ei;
      
          input FCore.Cache cache;
      
          input FCore.Graph graph;
      
          output BackendDAE.Shared shared;
      
        algorithm
      
        5322
          shared := BackendDAE.SHARED(BackendVariable.emptyVars(),
      
                                      BackendVariable.emptyVars(),
      
                                      BackendVariable.emptyVars(),
      
                                      BackendVariable.emptyVars(),
      
                                      BackendEquation.emptyEqns(),
      
                                      BackendEquation.emptyEqns(),
      
                                      {},
      
                                      {},
      
                                      cache,
      
                                      graph,
      
                                      AvlTreePathFunction.new(),
      
                                      emptyEventInfo(),
      
                                      {},
      
                                      backendDAEType,
      
                                      {},
      
                                      ei,
      
                                      emptyPartitionsInfo(),
      
                                      BackendDAE.emptyDAEModeData,
      
                                      NONE(),
      
                                      NONE(),
      
                                      {}
      
                                      );
      
        end createEmptyShared;
      
        public function emptyPartitionsInfo
      
          output BackendDAE.PartitionsInfo partitionsInfo;
      
        protected
      
          array<BackendDAE.BasePartition> basePartitions;
      
          array<BackendDAE.SubPartition> subPartitions;
      
        algorithm
      
        6417
          basePartitions := arrayCreate(0, BackendDAE.BASE_PARTITION(DAE.INFERRED_CLOCK(), 0));
      
        6417
          subPartitions := arrayCreate(0, BackendDAE.SUB_PARTITION(BackendDAE.DEFAULT_SUBCLOCK, false, {}));
      
        6417
          partitionsInfo := BackendDAE.PARTITIONS_INFO(basePartitions, subPartitions);
      
        end emptyPartitionsInfo;
      
        public function makeSingleEquationComp
      
          input Integer eqIdx;
      
          input Integer varIdx;
      
          output BackendDAE.StrongComponent comp;
      
        algorithm
      
        12
          comp := BackendDAE.SINGLEEQUATION(eqIdx,varIdx);
      
        end makeSingleEquationComp;
      
        public function getAliasVars "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.Variables outAliasVars;
      
        algorithm
      
        6240
          BackendDAE.DAE(shared=BackendDAE.SHARED(aliasVars=outAliasVars)) := inDAE;
      
        end getAliasVars;
      
        public function getGlobalKnownVarsFromDAE "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.Variables globalKnownVars;
      
        algorithm
      
        2228
          BackendDAE.DAE(shared=BackendDAE.SHARED(globalKnownVars=globalKnownVars)) := inDAE;
      
        end getGlobalKnownVarsFromDAE;
      
        public function setVars
      
          input BackendDAE.BackendDAE inDAE;
      
          input BackendDAE.Variables inVars;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.EqSystem syst;
      
          BackendDAE.Shared shared;
      
        algorithm
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.

        28
          BackendDAE.DAE(syst::systs, shared) := inDAE;
      
        28
          syst := setEqSystVars(syst, inVars);
      
        28
          outDAE := BackendDAE.DAE(syst::systs, shared);
      
        end setVars;
      
        public function setEqs
      
          input BackendDAE.BackendDAE inDAE;
      
          input BackendDAE.EquationArray inEqs;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.EqSystem syst;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        ✗
          BackendDAE.DAE(syst::systs, shared) := inDAE;
      
        ✗
          syst := setEqSystEqs(syst, inEqs);
      
        ✗
          outDAE := BackendDAE.DAE(syst::systs, shared);
      
        end setEqs;
      
        public function setAliasVars "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          input BackendDAE.Variables inAliasVars;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        1387
          BackendDAE.DAE(systs, shared) := inDAE;
      
        1387
          shared := setSharedAliasVars(shared, inAliasVars);
      
        1387
          outDAE := BackendDAE.DAE(systs, shared);
      
        end setAliasVars;
      
        public function setDAEGlobalKnownVars "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          input BackendDAE.Variables inGlobalKnownVars;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        6650
          BackendDAE.DAE(systs, shared) := inDAE;
      
        6650
          shared := setSharedGlobalKnownVars(shared, inGlobalKnownVars);
      
        6650
          outDAE := BackendDAE.DAE(systs, shared);
      
        end setDAEGlobalKnownVars;
      
        public function setFunctionTree "author: lochel"
      
          input BackendDAE.BackendDAE inDAE;
      
          input AvlTreePathFunction.Tree inFunctionTree;
      
          output BackendDAE.BackendDAE outDAE;
      
        protected
      
          BackendDAE.EqSystems systs;
      
          BackendDAE.Shared shared;
      
        algorithm
      
        4522
          BackendDAE.DAE(systs, shared) := inDAE;
      
        4522
          shared := setSharedFunctionTree(shared, inFunctionTree);
      
        4522
          outDAE := BackendDAE.DAE(systs, shared);
      
        end setFunctionTree;
      
        public function setEqSystEqs
      
          "Set ordered equations of input equation system to given equations."
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.EquationArray inEqs;
      
          output BackendDAE.EqSystem syst = inSyst;
      
        algorithm
      
        15882
          syst.orderedEqs := inEqs;
      
        end setEqSystEqs;
      
        public function setEqSystVars
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.Variables inVars;
      
          output BackendDAE.EqSystem outSyst;
      
        algorithm
      
          outSyst := match inSyst
      
            local
      
              BackendDAE.EqSystem syst;
      
            case syst as BackendDAE.EQSYSTEM()
      
        17494
              algorithm syst.orderedVars := inVars;
      
              then syst;
      
          end match;
      
        end setEqSystVars;
      
        public function setEqSystMatrices
      
          input BackendDAE.EqSystem inSyst;
      
          input Option<BackendDAE.AdjacencyMatrix> m = NONE();
      
          input Option<BackendDAE.AdjacencyMatrix> mT = NONE();
      
          input Option<BackendDAE.AdjacencyMatrixMapping> mapping = NONE();
      
          output BackendDAE.EqSystem outSyst;
      
        algorithm
      
          outSyst := match inSyst
      
            local
      
              BackendDAE.EqSystem syst;
      
            case syst as BackendDAE.EQSYSTEM()
      
              algorithm
      
        395445
                syst.m := m;
      
        395445
                syst.mT := mT;
      
        395445
                syst.mapping := mapping;
      
              then syst;
      
          end match;
      
        end setEqSystMatrices;
      
        public function clearEqSyst
      
          input BackendDAE.EqSystem inSyst;
      
          output BackendDAE.EqSystem outSyst;
      
        protected
      
          BackendDAE.Variables vars;
      
          BackendDAE.EquationArray eqs, removedEqs;
      
          BackendDAE.StateSets stateSets;
      
          BackendDAE.BaseClockPartitionKind partitionKind;
      
        algorithm
      
        52747
          BackendDAE.EQSYSTEM( orderedVars=vars, orderedEqs=eqs, stateSets=stateSets, partitionKind=partitionKind,
      
                               removedEqs=removedEqs ) := inSyst;
      
        52747
          outSyst := BackendDAE.EQSYSTEM( orderedVars=vars, orderedEqs=eqs, m=NONE(), mT=NONE(), mapping=NONE(), removedEqs=removedEqs,
      
                                          matching=BackendDAE.NO_MATCHING(), stateSets=stateSets, partitionKind=partitionKind );
      
        end clearEqSyst;
      
        public function setEqSystMatching
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.Matching matching;
      
          output BackendDAE.EqSystem outSyst;
      
        algorithm
      
          outSyst := match inSyst
      
            local
      
              BackendDAE.EqSystem syst;
      
            case syst as BackendDAE.EQSYSTEM()
      
        124358
              algorithm syst.matching := matching;
      
              then syst;
      
          end match;
      
        end setEqSystMatching;
      
        public function setEqSystStateSets
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.StateSets stateSets;
      
          output BackendDAE.EqSystem outSyst;
      
        algorithm
      
          outSyst := match inSyst
      
            local
      
              BackendDAE.EqSystem syst;
      
            case syst as BackendDAE.EQSYSTEM()
      
        ✗
              algorithm syst.stateSets := stateSets;
      
              then syst;
      
          end match;
      
        end setEqSystStateSets;
      
        public function setEqSystRemovedEqns
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.EquationArray removedEqs;
      
          output BackendDAE.EqSystem outSyst = inSyst;
      
        algorithm
      
        1104
          outSyst.removedEqs := removedEqs;
      
        end setEqSystRemovedEqns;
      
        public function setSharedRemovedEqns
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.EquationArray inRemovedEqs;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED() algorithm
      
        2171
              shared.removedEqs := inRemovedEqs;
      
            then shared;
      
          end match;
      
        end setSharedRemovedEqns;
      
        public function setSharedInitialEqns
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.EquationArray initialEqs;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
        ✗
              algorithm shared.initialEqs := initialEqs;
      
              then shared;
      
          end match;
      
        end setSharedInitialEqns;
      
        public function setSharedSymJacs
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.SymbolicJacobians symjacs;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
        1121
              algorithm shared.symjacs := symjacs;
      
              then shared;
      
          end match;
      
        end setSharedSymJacs;
      
        public function getSharedSymJacs
      
          input BackendDAE.Shared inShared;
      
          output BackendDAE.SymbolicJacobians outSymjacs;
      
        algorithm
      
          outSymjacs := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
        ✗
            case shared as BackendDAE.SHARED() then shared.symjacs;
      
          end match;
      
        end getSharedSymJacs;
      
        public function setSharedFunctionTree
      
          input BackendDAE.Shared inShared;
      
          input AvlTreePathFunction.Tree inFunctionTree;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
        168737
              algorithm shared.functionTree := inFunctionTree;
      
              then shared;
      
          end match;
      
        end setSharedFunctionTree;
      
        public function setSharedEventInfo
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.EventInfo eventInfo;
      
          output BackendDAE.Shared outShared = inShared;
      
        algorithm
      
        3876
          outShared.eventInfo := eventInfo;
      
        end setSharedEventInfo;
      
        public function setSharedGlobalKnownVars
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.Variables globalKnownVars;
      
          output BackendDAE.Shared outShared = inShared;
      
        algorithm
      
        58080
          outShared.globalKnownVars := globalKnownVars;
      
        end setSharedGlobalKnownVars;
      
        public function setSharedAliasVars
      
          input BackendDAE.Shared inShared;
      
          input BackendDAE.Variables aliasVars;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
        118249
              algorithm shared.aliasVars := aliasVars;
      
              then shared;
      
          end match;
      
        end setSharedAliasVars;
      
        public function setSharedOptimica
      
          input BackendDAE.Shared inShared;
      
          input list<DAE.Constraint> constraints;
      
          input list<DAE.ClassAttributes> classAttrs;
      
          output BackendDAE.Shared outShared;
      
        algorithm
      
          outShared := match inShared
      
            local
      
              BackendDAE.Shared shared;
      
            case shared as BackendDAE.SHARED()
      
              algorithm
      
        1085
                shared.constraints := constraints;
      
        1085
                shared.classAttrs := classAttrs;
      
              then shared;
      
          end match;
      
        end setSharedOptimica;
      
        public function collapseOrderedEqs
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.EquationArray outEqns;
      
        protected
      
          list<BackendDAE.Equation> eqsLst;
      
        algorithm
      
        ✗
          eqsLst := List.fold(inDAE.eqs, collapseRemovedEqs1, {});
      
        ✗
          outEqns := BackendEquation.listEquation(listAppend(eqsLst, BackendEquation.equationList(inDAE.shared.removedEqs)));
      
        end collapseOrderedEqs;
      
        public function collapseRemovedEqs
      
          input BackendDAE.BackendDAE inDAE;
      
          output BackendDAE.EquationArray outEqns;
      
        protected
      
          list<BackendDAE.Equation> eqsLst;
      
        algorithm
      
        2257
          eqsLst := List.fold(inDAE.eqs, collapseRemovedEqs1, {});
      
        2257
          outEqns := BackendEquation.listEquation(listAppend(eqsLst, BackendEquation.equationList(inDAE.shared.removedEqs)));
      
        end collapseRemovedEqs;
      
        protected function collapseRemovedEqs1
      
          input BackendDAE.EqSystem inSyst;
      
          input list<BackendDAE.Equation> inEqns;
      
          output list<BackendDAE.Equation> outEqns;
      
        algorithm
      
          2/2✓ Branch 1 taken 55067 times.
✓ Branch 2 taken 61 times.

        55128
          outEqns := if BackendDAEUtil.isClockedSyst(inSyst) then inEqns
      
                     else listAppend(BackendEquation.equationList(inSyst.removedEqs), inEqns);
      
        end collapseRemovedEqs1;
      
        public function emptyEventInfo
      
          output BackendDAE.EventInfo info;
      
        algorithm
      
        5322
          info := BackendDAE.EVENT_INFO({}, ZeroCrossings.new(), ZeroCrossings.new(), ZeroCrossings.new(), 0);
      
        end emptyEventInfo;
      
        public function getSubClock
      
          input BackendDAE.EqSystem inSyst;
      
          input BackendDAE.Shared inShared;
      
          output Option<BackendDAE.SubClock> outSubClock;
      
        algorithm
      
          outSubClock := match inSyst.partitionKind
      
            local
      
              Integer idx;
      
            case BackendDAE.CLOCKED_PARTITION(idx)
      
        61
              then SOME(inShared.partitionsInfo.subPartitions[idx].clock);
      
            else NONE();
      
          end match;
      
        end getSubClock;
      
        public function componentsEqual"outputs true if 1 strongly connected components are equal"
      
          input BackendDAE.StrongComponent comp1;
      
          input BackendDAE.StrongComponent comp2;
      
          output Boolean isEqual;
      
        algorithm
      
          isEqual := match(comp1,comp2)
      
            local
      
              Integer i1,i2, j1,j2;
      
              list<Integer> l1,l2,k1,k2;
      
              BackendDAE.InnerEquations l3,k3;
      
          case(BackendDAE.SINGLEEQUATION(eqn=i1,var=i2),BackendDAE.SINGLEEQUATION(eqn=j1,var=j2))
      
        ✗
          then intEq(i1,j1) and intEq(i2,j2);
      
          case(BackendDAE.EQUATIONSYSTEM(eqns=l1,vars=l2),BackendDAE.EQUATIONSYSTEM(eqns=k1,vars=k2))
      
        ✗
          then List.isEqualOnTrue(l1,k1,intEq) and List.isEqualOnTrue(l2,k2,intEq);
      
          case(BackendDAE.SINGLEARRAY(eqn=i1,vars=l1),BackendDAE.SINGLEARRAY(eqn=j1,vars=k1))
      
        ✗
          then intEq(i1,j1) and List.isEqualOnTrue(l1,k1,intEq);
      
          case(BackendDAE.SINGLEALGORITHM(eqn=i1,vars=l1),BackendDAE.SINGLEALGORITHM(eqn=j1,vars=k1))
      
        ✗
          then intEq(i1,j1) and List.isEqualOnTrue(l1,k1,intEq);
      
          case(BackendDAE.SINGLECOMPLEXEQUATION(eqn=i1,vars=l1),BackendDAE.SINGLECOMPLEXEQUATION(eqn=j1,vars=k1))
      
        ✗
          then intEq(i1,j1) and List.isEqualOnTrue(l1,k1,intEq);
      
          case(BackendDAE.SINGLEWHENEQUATION(eqn=i1,vars=l1),BackendDAE.SINGLEWHENEQUATION(eqn=j1,vars=k1))
      
        ✗
          then intEq(i1,j1) and List.isEqualOnTrue(l1,k1,intEq);
      
          case(BackendDAE.SINGLEIFEQUATION(eqn=i1,vars=l1),BackendDAE.SINGLEIFEQUATION(eqn=j1,vars=k1))
      
        ✗
          then intEq(i1,j1) and List.isEqualOnTrue(l1,k1,intEq);
      
          case(BackendDAE.TORNSYSTEM(strictTearingSet=BackendDAE.TEARINGSET(tearingvars=l1,residualequations=l2,innerEquations=l3)),BackendDAE.TORNSYSTEM(strictTearingSet=BackendDAE.TEARINGSET(tearingvars=k1,residualequations=k2,innerEquations=k3)))
      
        ✗
          then List.isEqualOnTrue(l1,k1,intEq) and List.isEqualOnTrue(l2,k2,intEq) and List.isEqualOnTrue(l3,k3,innerEquationsEqual);
      
          else false;
      
          end match;
      
        end componentsEqual;
      
        protected function innerEquationsEqual"compares 2 innerEquations from innerEquations in TearingSets"
      
          input BackendDAE.InnerEquation innerEquation1;
      
          input BackendDAE.InnerEquation innerEquation2;
      
          output Boolean isEqual;
      
        algorithm
      
          isEqual := match(innerEquation1,innerEquation2)
      
            local
      
              Integer i1,i2;
      
              list<Integer> l1,l2;
      
            case(BackendDAE.INNEREQUATION(eqn=i1,vars=l1),BackendDAE.INNEREQUATION(eqn=i2,vars=l2))
      
        ✗
             then intEq(i1,i2) and List.isEqualOnTrue(l1,l2,intEq);
      
            case(BackendDAE.INNEREQUATIONCONSTRAINTS(eqn=i1,vars=l1),BackendDAE.INNEREQUATIONCONSTRAINTS(eqn=i2,vars=l2))
      
        ✗
             then intEq(i1,i2) and List.isEqualOnTrue(l1,l2,intEq);
      
            else
      
             false;
      
          end match;
      
        end innerEquationsEqual;
      
        public function causalizeVarBindSystem"causalizes a system of variables and their binding-equations.
      
        author: waurich TUD 08.2015"
      
          input list<BackendDAE.Var> varLstIn;
      
          input Boolean isInitial;
      
          output list<list<Integer>> comps;
      
          output array<Integer> ass1;
      
          output array<Integer> ass2;
      
        protected
      
          Integer nVars,nEqs;
      
          BackendDAE.AdjacencyMatrix m,  mT;
      
          list<DAE.Exp> bindExps;
      
          list<BackendDAE.Equation> eqs;
      
        algorithm
      
        1069
          bindExps := List.map(varLstIn,BackendVariable.varBindExp);
      
        1069
          eqs := List.threadMap2(List.map(varLstIn,BackendVariable.varExp), bindExps, BackendEquation.generateEquation, DAE.emptyElementSource, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
      
        1069
          (m, mT) := BackendDAEUtil.adjacencyMatrixDispatch(BackendVariable.listVar1(varLstIn), BackendEquation.listEquation(eqs), BackendDAE.ABSOLUTE(), NONE(), isInitial);
      
        1069
          nVars := listLength(varLstIn);
      
        1069
          nEqs := listLength(eqs);
      
        1069
          ass1 := arrayCreate(nVars, -1);
      
        1069
          ass2 := arrayCreate(nEqs, -1);
      
        1069
          Matching.matchingExternalsetAdjacencyMatrix(nVars, nEqs, m);
      
        1069
          BackendDAEEXT.matching(nVars, nEqs, 5, -1, 0.0, 1);
      
        1069
          BackendDAEEXT.getAssignment(ass2, ass1);
      
        1069
          comps := Sorting.TarjanTransposed(mT, ass2);
      
        end causalizeVarBindSystem;
      
        public function traverseEqSystemStrongComponents
      
        "This function goes through the strong components of a EqSystem and pass
      
         the variables and equation with their indexes to the traversing function.
      
         It fail if the EqSytem does not have the matching and strong components are
      
         empty. It does not change the input EqSystem."
      
          replaceable type Type_a subtypeof Any;
      
          input BackendDAE.EqSystem syst;
      
          input FuncExpType func;
      
          input Type_a inTypeA;
      
          output Type_a outTypeA = inTypeA;
      
          partial function FuncExpType
      
            input list<BackendDAE.Equation> inEqns;
      
            input list<BackendDAE.Var> inVars;
      
            input list<Integer> varIdxs;
      
            input list<Integer> eqnIdxs;
      
            input Type_a inA;
      
            output Type_a outA;
      
          end FuncExpType;
      
        protected
      
          BackendDAE.StrongComponents comps;
      
          BackendDAE.Variables varArr;
      
          BackendDAE.EquationArray eqnArr;
      
          list<BackendDAE.Var> vars;
      
          list<BackendDAE.Equation> eqns;
      
          list<Integer> varIdxs, eqnIdxs;
      
          String name;
      
        algorithm
      
          try
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.

        26
            BackendDAE.EQSYSTEM(matching    = BackendDAE.MATCHING(comps=comps),
      
                                orderedVars = varArr,
      
                                orderedEqs  = eqnArr) := syst;
      
          2/2✓ Branch 0 taken 9833 times.
✓ Branch 1 taken 26 times.

        9859
            for component in comps loop
      
        9833
              (vars, varIdxs, eqns, eqnIdxs) := getStrongComponentVarsAndEquations(component, varArr, eqnArr);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9833 times.

        9833
              outTypeA := func(eqns, vars, varIdxs, eqnIdxs, outTypeA);
      
            end for;
      
          else
      
        ✗
            (_, _, name) := System.dladdr(func);
      
        ✗
            Error.addInternalError("BackendDAEUtil.traverseEqSystemStrongComponents failed " +
      
                                    "with function:\n" +  name + "\n", sourceInfo());
      
        ✗
            fail();
      
          end try;
      
        end traverseEqSystemStrongComponents;
      
        public function getStrongComponentsVarsAndEquations"gets the variables and and the equations from all sccs.
      
        author: Waurich TUD 09-2015"
      
          input BackendDAE.StrongComponents comps;
      
          input BackendDAE.Variables varArr;
      
          input BackendDAE.EquationArray eqArr;
      
          output list<BackendDAE.Var> varsOut = {};
      
          output list<Integer> varIdxsOut = {};
      
          output list<BackendDAE.Equation> eqsOut = {};
      
          output list<Integer> eqIdxsOut = {};
      
        protected
      
          BackendDAE.StrongComponent comp;
      
          list<BackendDAE.Equation> eqs;
      
          list<BackendDAE.Var> vars;
      
          list<Integer> vIdxs,eIdxs;
      
        algorithm
      
        ✗
          for comp in comps loop
      
        ✗
            (vars,vIdxs,eqs,eIdxs) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp, varArr, eqArr);
      
        ✗
            varsOut := listAppend(vars,varsOut);
      
        ✗
            varIdxsOut := listAppend(vIdxs,varIdxsOut);
      
        ✗
            eqsOut := listAppend(eqs,eqsOut);
      
        ✗
            eqIdxsOut := listAppend(eIdxs,eqIdxsOut);
      
          end for;
      
        ✗
          varsOut := listReverse(varsOut);
      
        ✗
          varIdxsOut := listReverse(varIdxsOut);
      
        ✗
          eqsOut := listReverse(eqsOut);
      
        ✗
          eqIdxsOut := listReverse(eqIdxsOut);
      
        end getStrongComponentsVarsAndEquations;
      
        public function getStrongComponentVarsAndEquations"gets the variables and and the equations from the scc.
      
        author: Waurich TUD 09-2015"
      
          input BackendDAE.StrongComponent comp;
      
          input BackendDAE.Variables varArr;
      
          input BackendDAE.EquationArray eqArr;
      
          output list<BackendDAE.Var> varsOut;
      
          output list<Integer> varIdxs;
      
          output list<BackendDAE.Equation> eqsOut;
      
          output list<Integer> eqIdcxs;
      
        algorithm
      
          (varsOut,varIdxs,eqsOut,eqIdcxs) := match comp
      
            local
      
              Integer vidx,eidx;
      
              list<Integer> vidxs,eidxs, otherEqns, otherVars;
      
              list<list<Integer>> otherVarsLst;
      
              BackendDAE.Equation eq;
      
              BackendDAE.Var var;
      
              list<BackendDAE.Equation> eqs;
      
              list<BackendDAE.Var> vars;
      
              BackendDAE.InnerEquations innerEquations;
      
          case BackendDAE.SINGLEEQUATION(eqn=eidx,var=vidx)
      
            algorithm
      
        149389
              var := BackendVariable.getVarAt(varArr,vidx);
      
        149389
              eq := BackendEquation.get(eqArr,eidx);
      
            then ({var},{vidx},{eq},{eidx});
      
          case BackendDAE.EQUATIONSYSTEM(eqns=eidxs,vars=vidxs)
      
            algorithm
      
        560
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        560
              eqs := BackendEquation.getList(eidxs,eqArr);
      
            then (vars,vidxs,eqs,eidxs);
      
          case BackendDAE.SINGLEARRAY(eqn=eidx,vars=vidxs)
      
            algorithm
      
        529
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        529
              eq := BackendEquation.get(eqArr,eidx);
      
            then (vars,vidxs,{eq},{eidx});
      
          case BackendDAE.SINGLEALGORITHM(eqn=eidx,vars=vidxs)
      
            algorithm
      
        480
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        480
              eq := BackendEquation.get(eqArr,eidx);
      
            then (vars,vidxs,{eq},{eidx});
      
          case BackendDAE.SINGLECOMPLEXEQUATION(eqn=eidx,vars=vidxs)
      
            algorithm
      
        791
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        791
              eq := BackendEquation.get(eqArr,eidx);
      
            then (vars,vidxs,{eq},{eidx});
      
          case BackendDAE.SINGLEWHENEQUATION(eqn=eidx,vars=vidxs)
      
            algorithm
      
        424
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        424
              eq := BackendEquation.get(eqArr,eidx);
      
            then (vars,vidxs,{eq},{eidx});
      
          case BackendDAE.SINGLEIFEQUATION(eqn=eidx,vars=vidxs)
      
            algorithm
      
        ✗
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        ✗
              eq := BackendEquation.get(eqArr,eidx);
      
            then (vars,vidxs,{eq},{eidx});
      
          case BackendDAE.TORNSYSTEM(strictTearingSet = BackendDAE.TEARINGSET(residualequations=eidxs,tearingvars=vidxs, innerEquations=innerEquations))
      
            algorithm
      
        1792
              (otherEqns,otherVarsLst,_) := List.map_3(innerEquations, BackendDAEUtil.getEqnAndVarsFromInnerEquation);
      
        1792
              otherVars := List.flatten(otherVarsLst);
      
        1792
              eidxs := listAppend(otherEqns,eidxs);
      
        1792
              vidxs := listAppend(otherVars,vidxs);
      
        1792
              vars := List.map1(vidxs,BackendVariable.getVarAtIndexFirst,varArr);
      
        1792
              eqs := BackendEquation.getList(eidxs,eqArr);
      
            then (vars,vidxs,eqs,eidxs);
      
          end match;
      
        end getStrongComponentVarsAndEquations;
      
        public function getStrongComponentEquations"gets all equations from a component"
      
          input list<BackendDAE.StrongComponent> comps;
      
          input BackendDAE.EquationArray eqs;
      
          input BackendDAE.Variables vars;
      
          output list<BackendDAE.Equation> eqsOut;
      
        protected
      
          BackendDAE.StrongComponent comp;
      
          list<BackendDAE.Equation> eqLst;
      
        algorithm
      
          eqsOut := {};
      
          2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 3 times.

        69
          for comp in comps loop
      
        66
            (_,_,eqLst,_) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp,vars,eqs);
      
        66
            eqsOut := listAppend(eqLst,eqsOut);
      
          end for;
      
        end getStrongComponentEquations;
      
        public function isFuncCallWithNoDerAnnotation"checks if the equation is a function call which has a noDerivative annotation.
      
        Outputs the noDerivative binding crefs as well.
      
        author: waurich TUD 10-2015"
      
          input BackendDAE.Equation eq;
      
          input AvlTreePathFunction.Tree functionTree;
      
          output Boolean isFuncCallWithNoDerAnno;
      
          output list<DAE.ComponentRef> noDerivativeInputs;
      
        algorithm
      
        53096
          (_,(_,noDerivativeInputs)) := BackendEquation.traverseExpsOfEquation(eq,function Expression.traverseExpTopDown(func=isFuncCallWithNoDerAnnotation1),(functionTree,{}));
      
          1/2✓ Branch 0 taken 53096 times.
✗ Branch 1 not taken.

        53096
          isFuncCallWithNoDerAnno := not listEmpty(noDerivativeInputs);
      
        end isFuncCallWithNoDerAnnotation;
      
        public function isFuncCallWithNoDerAnnotation1 "checks if the exp is a function call which has a noDerivative annotation.
      
        Collects all crefs which dont need a derivative.
      
        author: waurich TUD 10-2015"
      
          input DAE.Exp expIn;
      
          input tuple<AvlTreePathFunction.Tree, list<DAE.ComponentRef>> tplIn; // <functionTree, foldList to collect noDer-input-vars>
      
          output DAE.Exp expOut;
      
          output Boolean cont;
      
          output tuple<AvlTreePathFunction.Tree, list<DAE.ComponentRef>> tplOut;
      
        algorithm
      
          (expOut, cont, tplOut) := matchcontinue(expIn, tplIn)
      
            local
      
              list<Integer> inputPos;
      
              Absyn.Path path;
      
              DAE.FunctionDefinition mapper;
      
              AvlTreePathFunction.Tree functionTree;
      
              list<DAE.ComponentRef> crefsIn, noDerivativeInputs;
      
              list<DAE.Exp> expLst;
      
              list<tuple<Integer,DAE.derivativeCond>> conditionRefs;
      
          case(DAE.CALL(path=path,expLst=expLst),(functionTree,crefsIn))
      
            algorithm
      
        53420
              (mapper, _) := Differentiate.getFunctionMapper(path, functionTree);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12635 times.

        12635
              DAE.FUNCTION_DER_MAPPER(conditionRefs=conditionRefs) := mapper;
      
        12635
              inputPos := getNoDerivativeInputPosition(conditionRefs);
      
        12635
              expLst := List.map1(inputPos,List.getIndexFirst,expLst);
      
        12635
              expLst := List.filter1OnTrue(expLst,isNotFunctionCall,functionTree);
      
        12635
              noDerivativeInputs := List.flatten(List.map(expLst,Expression.getAllCrefs));
      
                //print("crefs: "+stringDelimitList(List.map(noDerivativeInputs,ComponentReference.crefStr),", ")+"\n");
      
        12635
            then (expIn,true,(functionTree,listAppend(noDerivativeInputs,crefsIn)));
      
          else
      
            then (expIn,true,tplIn);
      
          end matchcontinue;
      
        end isFuncCallWithNoDerAnnotation1;
      
        public function isNotFunctionCall
      
        "Returns true if the given expression is something different than a function call.
      
        author: waurich TUD 10-2015"
      
          input DAE.Exp inExp;
      
          input AvlTreePathFunction.Tree funcsIn;
      
          output Boolean outIsNoCall;
      
        algorithm
      
          outIsNoCall := matchcontinue inExp
      
            local
      
              Absyn.Path path;
      
              DAE.Function func;
      
            case DAE.CALL(path=path)
      
              algorithm
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 502 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 502 times.

        508
                SOME(func) := AvlTreePathFunction.get(funcsIn,path);
      
        502
                 then listEmpty(DAEUtil.getFunctionElements(func));
      
            else true;
      
          end matchcontinue;
      
        end isNotFunctionCall;
      
        protected function getNoDerivativeInputPosition"get the position idx for the input-var which does not need a derivation from the NoDerivative annotations"
      
          input list<tuple<Integer,DAE.derivativeCond>> conds;
      
          output list<Integer> IdxsOut = {};
      
        algorithm
      
          2/2✓ Branch 0 taken 12465 times.
✓ Branch 1 taken 12635 times.

        25100
          for c in conds loop
      
            IdxsOut := match c
      
              local
      
                Integer idx;
      
              case (idx,DAE.NO_DERIVATIVE(_))
      
                then idx::IdxsOut;
      
              else IdxsOut;
      
            end match;
      
          end for;
      
        end getNoDerivativeInputPosition;
      
        public function checkAdjacencyMatrixSolvability "Performs a limited matching algorithm to sometimes figure out which equations are superfluous or which variables are never solved for."
      
          input BackendDAE.EqSystem syst;
      
          input AvlTreePathFunction.Tree functionTree;
      
          input Boolean isInitial;
      
        protected
      
          Integer varSize, eqnSize, v, eq, count;
      
          BackendDAE.AdjacencyMatrix m, mT, mOrig, mTOrig;
      
          list<Integer> vars, eqs;
      
          array<Integer> solvedVars;
      
          array<list<tuple<DAE.ComponentRef,Integer>>> solvedEqs;
      
          list<tuple<DAE.ComponentRef,Integer>> names;
      
          Integer errors = 0, numSolved = 0, eqSize, lenInfos, lenVars;
      
          Boolean cont = true;
      
          BackendDAE.Variables varsArray;
      
          BackendDAE.Var var;
      
          BackendDAE.EquationArray eqsArray;
      
          BackendDAE.Equation _equation;
      
          constant Boolean debug=false;
      
          constant Boolean alwaysCheck=false;
      
          SourceInfo info;
      
          String str;
      
        algorithm
      
        1095
          varsArray := syst.orderedVars;
      
        1095
          eqsArray := syst.orderedEqs;
      
        1095
          varSize := BackendVariable.varsSize(varsArray);
      
        1095
          eqnSize := BackendEquation.equationArraySize(eqsArray);
      
          2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1091 times.

        1095
          if varSize <> eqnSize then
      
          2/2✓ Branch 2 taken 1 time.
✓ Branch 3 taken 3 times.

        9
            Error.addMessage(if varSize > eqnSize then Error.UNDERDET_EQN_SYSTEM else Error.OVERDET_EQN_SYSTEM, {String(eqnSize), String(varSize)});
      
          elseif not alwaysCheck then
      
        1091
            return;
      
          end if;
      
        4
          (_, mOrig, mTOrig) := BackendDAEUtil.getAdjacencyMatrixfromOption(syst, BackendDAE.ABSOLUTE(), SOME(functionTree), isInitial);
      
        4
          m := arrayCopy(mOrig);
      
        4
          mT := arrayCopy(mTOrig);
      
        4
          solvedVars := arrayCreate(arrayLength(mT), 0);
      
        4
          solvedEqs := arrayCreate(arrayLength(m), {});
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        10
          for i in 1:arrayLength(m) /* Not eqnSize; that is the size including arrays */ loop
      
        6
            _equation := BackendEquation.get(eqsArray, i);
      
        6
            info := BackendEquation.equationInfo(_equation);
      
        6
            eqSize := BackendEquation.equationSize(_equation);
      
        6
            count := listLength(arrayGet(m, i));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.

        6
            if eqSize > count then
      
        ✗
              str := stringDelimitList(list(ComponentReferenceBasics.printComponentRefStr(BackendVariable.varCref(BackendVariable.getVarAt(varsArray, j))) for j in arrayGet(m, i)), ", ");
      
        ✗
              Error.addSourceMessage(Error.EQUATION_NOT_SOLVABLE_DIFFERENT_COUNT, {BackendDump.equationString(_equation), String(eqSize), String(count), str}, info);
      
        ✗
              fail();
      
            end if;
      
          end for;
      
          if debug then
      
            print("Got adjacency matrix "+String(varSize)+" "+String(arrayLength(m))+" "+String(eqnSize)+" "+String(arrayLength(mT))+"...\n");
      
          end if;
      
          count := 0;
      
          2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4 times.

        12
          while cont and count < 1000 loop
      
            cont := false;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.

        8
            count := count+1;
      
          1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.

        20
            for i in 1:arrayLength(m) /* Not eqnSize; that is the size including arrays */ loop
      
          2/2✓ Branch 1 taken 6 times.
✓ Branch 2 taken 6 times.

        12
              if not listEmpty(arrayGet(solvedEqs, i)) then
      
        6
                continue;
      
              end if;
      
        6
              _equation := BackendEquation.get(eqsArray, i);
      
        6
              info := BackendEquation.equationInfo(_equation);
      
        6
              eqSize := BackendEquation.equationSize(_equation);
      
        6
              vars := arrayGet(m, i);
      
        6
              lenVars := listLength(vars);
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 5 times.

        6
              if eqSize == 0 then
      
        1
                arrayUpdate(solvedEqs, i, {(DAE.emptyCref,0)});
      
        1
                continue;
      
              end if;
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.

        5
              if lenVars <= eqSize then
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 2 times.

        3
                if lenVars < eqSize then
      
        1
                  variableDoesNotFitInEquation(i, vars, mOrig, eqsArray, varsArray, solvedVars);
      
        1
                  errors := errors+1;
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
                  if lenVars == 0 then
      
        2
                    arrayUpdate(solvedEqs, i, (DAE.emptyCref,0)::arrayGet(solvedEqs,i));
      
                  end if;
      
                end if;
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3 times.

        5
                for v in vars loop
      
        2
                  var := BackendVariable.getVarAt(varsArray, v);
      
        4
                  arrayUpdate(solvedEqs, i, (var.varName,v)::arrayGet(solvedEqs,i));
      
        2
                  arrayUpdate(solvedVars, v, i);
      
        2
                  eqs := arrayGet(mT, v);
      
          2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.

        6
                  for eq in eqs loop
      
                    // Remove references to the variable in other equations since we can't solve it there
      
        4
                    arrayUpdate(m, eq, List.setDifference(arrayGet(m, eq), vars));
      
                  end for;
      
                  numSolved := numSolved+1;
      
                end for;
      
                cont := true;
      
              end if;
      
            end for;
      
            if debug then
      
              print("Number of equations solved: " + String(numSolved-errors) + "\n");
      
              print("Number of errors: " + String(errors) + "\n");
      
            end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.

        24
            for i in 1:arrayLength(mT) /* = varSize */ loop
      
          2/2✓ Branch 1 taken 10 times.
✓ Branch 2 taken 6 times.

        16
              if 0 <> arrayGet(solvedVars, i) then
      
        10
                continue;
      
              end if;
      
        6
              eqs := arrayGet(mT, i);
      
        6
              var := BackendVariable.getVarAt(varsArray, i);
      
        6
              info := var.source.info;
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.

        6
              if listEmpty(eqs) then
      
          8/8✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 3 times.
✓ Branch 15 taken 4 times.
✓ Branch 16 taken 3 times.

        16
                Error.addSourceMessage(Error.VAR_NO_REMAINING_EQN, {
      
                  ComponentReferenceBasics.printComponentRefStr(var.varName),
      
                  stringAppendList(list("\n  Equation " + String(eq) + ": " + BackendDump.equationString(BackendEquation.get(eqsArray, eq)) + ", which needs to solve for " + stringDelimitList(list(ComponentReferenceBasics.printComponentRefStr(Util.tuple21(tpl)) for tpl in arrayGet(solvedEqs, eq)), ", ") for eq in arrayGet(mTOrig, i)))
      
                  }, info);
      
        3
                arrayUpdate(solvedVars, i, -1);
      
              elseif listLength(eqs) == 1 then
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.

        3
                {eq} := eqs;
      
        3
                eqSize := BackendEquation.equationSize(BackendEquation.get(eqsArray, eq));
      
        3
                names := arrayGet(solvedEqs, eq);
      
        3
                lenInfos := listLength(names);
      
        3
                arrayUpdate(solvedVars, i, eq);
      
        6
                arrayUpdate(solvedEqs, eq, (var.varName,i)::names);
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 2 times.

        3
                if lenInfos >= eqSize then
      
        1
                  variableDoesNotFitInEquation(eq, {i}, mOrig, eqsArray, varsArray, solvedVars);
      
        1
                  errors := errors+1;
      
                end if;
      
        3
                vars := arrayGet(m, eq);
      
          1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.

        3
                if lenInfos+1 >= eqSize then // TODO: FIXME
      
          2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.

        9
                  for v in vars loop
      
                    // Remove references to the equation in other variables since we can't solve it there
      
        6
                    arrayUpdate(mT, v, List.setDifference(arrayGet(mT, v), eqs));
      
                  end for;
      
                end if;
      
                numSolved := numSolved+1;
      
                cont := true;
      
              end if;
      
            end for;
      
            if debug then
      
              print("Number of equations solved: " + String(numSolved-errors) + "\n");
      
              print("Number of errors: " + String(errors) + "\n");
      
            end if;
      
          end while;
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.

        4
          true := 0 == errors;
      
          if alwaysCheck and varSize == eqnSize then
      
            return;
      
          end if;
      
          if debug then
      
            for i in 1:arrayLength(mT) /* = varSize */ loop
      
              var := BackendVariable.getVarAt(varsArray, i);
      
              if 0 == arrayGet(solvedVars, i) then
      
                print("Remaining unsolved variable:" + ComponentReferenceBasics.printComponentRefStr(var.varName) + "\n");
      
              end if;
      
            end for;
      
            for i in 1:arrayLength(m) /* = varSize */ loop
      
              _equation := BackendEquation.get(eqsArray, i);
      
              eqnSize := BackendEquation.equationSize(_equation);
      
              count := listLength(arrayGet(solvedEqs, i));
      
              if eqnSize <> count then
      
                vars := arrayGet(m, i);
      
                print("Remaining vars: " + stringDelimitList(list(String(j) for j in vars), ", ") + "\n");
      
                if count > 0 then
      
                  str := stringDelimitList(list(ComponentReferenceBasics.printComponentRefStr(Util.tuple21(e)) for e in arrayGet(solvedEqs, i)), ", ");
      
                  print("Remaining equation (already solved "+str+"): " + BackendDump.equationString(_equation) + "\n");
      
                else
      
                  print("Remaining equation: " + BackendDump.equationString(_equation) + "\n");
      
                end if;
      
              end if;
      
            end for;
      
          end if;
      
        2
          fail();
      
        end checkAdjacencyMatrixSolvability;
      
        protected function variableDoesNotFitInEquation
      
          input Integer eq;
      
          input list<Integer> vars;
      
          input BackendDAE.AdjacencyMatrix m;
      
          input BackendDAE.EquationArray eqsArray;
      
          input BackendDAE.Variables varsArray;
      
          input array<Integer> solvedVars;
      
        protected
      
          BackendDAE.Equation _equation;
      
          list<Integer> varsInOrig, eqsInOrig;
      
          String eqsString;
      
          SourceInfo info;
      
          Integer eqSize;
      
        algorithm
      
        2
          _equation := BackendEquation.get(eqsArray, eq);
      
        2
          info := BackendEquation.equationInfo(_equation);
      
        2
          eqSize := BackendEquation.equationSize(_equation);
      
        2
          varsInOrig := List.setDifference(arrayGet(m, eq), vars);
      
          6/6✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 1 time.
✓ Branch 6 taken 2 times.

        4
          eqsInOrig := List.sortedUnique(List.sort(list(arrayGet(solvedVars,myVar) for myVar guard arrayGet(solvedVars,myVar)>0 in varsInOrig), intGt), intEq);
      
          4/4✓ Branch 0 taken 1 time.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 2 times.

        3
          eqsString := stringAppendList(list("\n    Equation " + String(eqNum) + " (size: "+String(BackendEquation.equationSize(BackendEquation.get(eqsArray, eqNum)))+"): " + BackendDump.equationString(BackendEquation.get(eqsArray, eqNum)) for eqNum in eqsInOrig));
      
        10
          Error.addSourceMessage(Error.EQN_NO_SPACE_TO_SOLVE, {
      
            String(eq),
      
            String(eqSize),
      
            BackendDump.equationString(_equation),
      
            getVariableNamesForErrorMessage(varsArray, vars),
      
            getVariableNamesForErrorMessage(varsArray, varsInOrig),
      
            eqsString
      
            }, info);
      
        end variableDoesNotFitInEquation;
      
        protected function getVariableNamesForErrorMessage
      
          input BackendDAE.Variables varsArray;
      
          input list<Integer> vars;
      
          output String names;
      
        algorithm
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 time.

        4
          if listEmpty(vars) then
      
            names := "";
      
          else
      
          4/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 3 times.

        6
            names := " " + stringDelimitList(list(ComponentReferenceBasics.printComponentRefStr(BackendVariable.varCref(BackendVariable.getVarAt(varsArray, v))) for v in vars), ", ");
      
          end if;
      
        end getVariableNamesForErrorMessage;
      
        // =============================================================================
      
        // warn about iteration variables with no nominal attribute
      
        //
      
        // =============================================================================
      
        protected function warnAboutIterationVariablesWithNoNominal
      
        " author: ptaeuber"
      
          input BackendDAE.BackendDAE inDAE;
      
        protected
      
          BackendDAE.StrongComponents comps;
      
          String daeTypeStr, compKind;
      
          list<Integer> vlst = {};
      
          list<BackendDAE.Var> vars;
      
        algorithm
      
        ✗
          daeTypeStr := BackendDump.printBackendDAEType2String(inDAE.shared.backendDAEType);
      
        ✗
          for syst in inDAE.eqs loop
      
        ✗
            BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=comps)) := syst;
      
            // Go through all the strongly connected components.
      
        ✗
            for comp in comps loop
      
              // Get the component's variables.
      
              (compKind, vlst) := match comp
      
                case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_NONLINEAR())
      
        ✗
                  then ("nonlinear equation system in the " + daeTypeStr + " DAE:", vlst);
      
                case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_GENERIC())
      
        ✗
                  then ("equation system with analytic Jacobian in the " + daeTypeStr + " DAE:", vlst);
      
                case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_NO_ANALYTIC())
      
        ✗
                  then ("equation system without analytic Jacobian in the " + daeTypeStr + " DAE:", vlst);
      
                case BackendDAE.TORNSYSTEM(strictTearingSet=BackendDAE.TEARINGSET(tearingvars = vlst), linear = false)
      
        ✗
                  then ("torn nonlinear equation system in the " + daeTypeStr + " DAE:", vlst);
      
                // If the component is none of these types, do nothing.
      
                else ("", {});
      
              end match;
      
        ✗
              if not listEmpty(vlst) then
      
                // Filter out the variables that are missing start values.
      
        ✗
                vars := List.map1r(vlst, BackendVariable.getVarAt, syst.orderedVars);
      
        ✗
                vars := list(v for v guard(not BackendVariable.varHasNominalValue(v)) in vars);
      
                // Print a warning if we found any variables with missing start values.
      
        ✗
                if not listEmpty(vars) then
      
        ✗
                  Error.addCompilerWarning(BackendDump.varListStringIndented(vars, "Iteration variables with no nominal value in " + compKind));
      
                end if;
      
              end if;
      
            end for;
      
          end for;
      
        end warnAboutIterationVariablesWithNoNominal;
      
        public function getLinearfromJacType "  author: Frenkel TUD 2012-09"
      
          input BackendDAE.JacobianType jacType;
      
          output Boolean linear;
      
        algorithm
      
          linear := match jacType
      
            case BackendDAE.JAC_CONSTANT() then true;
      
            case BackendDAE.JAC_LINEAR() then true;
      
            case BackendDAE.JAC_NONLINEAR() then false;
      
            case BackendDAE.JAC_NO_ANALYTIC() then false;
      
          end match;
      
        end getLinearfromJacType;
      
        public function containsHomotopyCall
      
          input DAE.Exp inExp;
      
          input Boolean inHomotopy;
      
          output DAE.Exp outExp;
      
          output Boolean outHomotopy;
      
        algorithm
      
          3/4✓ Branch 0 taken 54648 times.
✓ Branch 1 taken 528 times.
✓ Branch 3 taken 55176 times.
✗ Branch 4 not taken.

        109824
          (outExp, outHomotopy) := Expression.traverseExpTopDown(inExp, containsHomotopyCall2, inHomotopy);
      
        end containsHomotopyCall;
      
        protected function containsHomotopyCall2
      
          input DAE.Exp inExp;
      
          input Boolean inHomotopy;
      
          output DAE.Exp outExp = inExp;
      
          output Boolean cont;
      
          output Boolean outHomotopy;
      
        algorithm
      
          (outExp, outHomotopy, cont) := match(inExp, inHomotopy)
      
            case (_, true)
      
             then (inExp, true, false);
      
            case (DAE.CALL(path=Absyn.IDENT(name="homotopy")), _)
      
             then (inExp, true, false);
      
            case (DAE.CREF(componentRef=DAE.CREF_IDENT(ident=BackendDAE.homotopyLambda)), _)
      
             then (inExp, true, false);
      
            else (inExp, inHomotopy, true);
      
          end match;
      
        end containsHomotopyCall2;
      
        public function doIndexReduction
      
          input BackendDAE.MatchingOptions opt;
      
          output Boolean b;
      
        algorithm
      
          b := match opt
      
            case (BackendDAE.INDEX_REDUCTION(), _) then true;
      
            else false;
      
          end match;
      
        end doIndexReduction;
      
        public function markNonlinearIterationVariables
      
          input output BackendDAE.BackendDAE dae;
      
        algorithm
      
          4/4✓ Branch 0 taken 3918 times.
✓ Branch 1 taken 1060 times.
✓ Branch 2 taken 3918 times.
✓ Branch 3 taken 1060 times.

        4978
          dae.eqs := list(markNonlinearIterationVariablesEqSystem(syst) for syst in dae.eqs);
      
        end markNonlinearIterationVariables;
      
        protected function markNonlinearIterationVariablesEqSystem
      
          input output BackendDAE.EqSystem syst;
      
        algorithm
      
          syst := match syst
      
            local
      
              BackendDAE.StrongComponents comps;
      
              UnorderedSet<DAE.ComponentRef> set = UnorderedSet.new(ComponentReferenceBasics.hashComponentRef, ComponentReferenceBasics.crefEqual);
      
            case BackendDAE.EQSYSTEM(matching = BackendDAE.MATCHING(comps = comps)) algorithm
      
          2/2✓ Branch 0 taken 41587 times.
✓ Branch 1 taken 3918 times.

        45505
              for comp in comps loop
      
        41587
                markNonlinearIterationVariablesStrongComponent(comp, set);
      
              end for;
      
        3918
              (syst.orderedVars, _) := BackendVariable.traverseBackendDAEVarsWithUpdate(syst.orderedVars, markNonlinearIterationVariable, set);
      
            then syst;
      
            else syst;
      
          end match;
      
        end markNonlinearIterationVariablesEqSystem;
      
        protected function markNonlinearIterationVariablesStrongComponent
      
          input BackendDAE.StrongComponent comp;
      
          input UnorderedSet<DAE.ComponentRef> set;
      
        protected
      
          list<BackendDAE.Var> nonlinear_iteration_vars;
      
        algorithm
      
          nonlinear_iteration_vars := match comp
      
            local
      
              BackendDAE.Jacobian jac;
      
        425
            case BackendDAE.TORNSYSTEM(strictTearingSet=BackendDAE.TEARINGSET(jac=jac), linear=false)   then SymbolicJacobian.getNonLinearVariables(jac);
      
        227
            case BackendDAE.EQUATIONSYSTEM(jac=jac, jacType=BackendDAE.JAC_GENERIC())                   then SymbolicJacobian.getNonLinearVariables(jac);
      
                                                                                                        else {};
      
          end match;
      
          2/2✓ Branch 0 taken 387 times.
✓ Branch 1 taken 41587 times.

        41974
          for var in nonlinear_iteration_vars loop
      
        387
            UnorderedSet.add(var.varName, set);
      
          end for;
      
        end markNonlinearIterationVariablesStrongComponent;
      
        protected function markNonlinearIterationVariable
      
          input output BackendDAE.Var var;
      
          input output UnorderedSet<DAE.ComponentRef> set;
      
        algorithm
      
          2/2✓ Branch 1 taken 61703 times.
✓ Branch 2 taken 386 times.

        62089
          if UnorderedSet.contains(var.varName, set) then
      
        386
            var := BackendVariable.setVarInitNonlinear(var, true);
      
          end if;
      
        end markNonlinearIterationVariable;
      
        annotation(__OpenModelica_Interface="backend");
      
        end BackendDAEUtil;