Reimplementation of the c runtime homotopy support

Compiler/BackEnd/BackendDAEUtil.mo

@@ -6818,8 +6818,6 @@ public function getSolvedSystem "Run the equation system pipeline."
   output BackendDAE.BackendDAE outSimDAE;
   output BackendDAE.BackendDAE outInitDAE;
   output Option<BackendDAE.InlineData > outInlineData;
-  output Boolean outUseHomotopy "true if homotopy(...) is used during initialization";
-  output Option<BackendDAE.BackendDAE> outInitDAE_lambda0;
   output list<BackendDAE.Equation> outRemovedInitialEquationLst;
 protected
   BackendDAE.BackendDAE dae, simDAE;
@@ -6877,7 +6875,7 @@ algorithm
   end if;
 
   // generate system for initialization
-  (outInitDAE, outUseHomotopy, outInitDAE_lambda0, outRemovedInitialEquationLst, globalKnownVars) := Initialization.solveInitialSystem(dae);
+  (outInitDAE, outRemovedInitialEquationLst, globalKnownVars) := Initialization.solveInitialSystem(dae);
 
   // use function tree from initDAE further for simDAE
   simDAE := BackendDAEUtil.setFunctionTree(dae, BackendDAEUtil.getFunctions(outInitDAE.shared));

Compiler/BackEnd/Initialization.mo

@@ -80,14 +80,11 @@ public function solveInitialSystem "author: lochel
   This function generates a algebraic system of equations for the initialization and solves it."
   input BackendDAE.BackendDAE inDAE "simulation system";
   output BackendDAE.BackendDAE outInitDAE "initialization system";
-  output Boolean outUseHomotopy;
-  output Option<BackendDAE.BackendDAE> outInitDAE_lambda0 "initialization system for lambda=0";
   output list<BackendDAE.Equation> outRemovedInitialEquations;
   output BackendDAE.Variables outGlobalKnownVars;
 protected
   BackendDAE.BackendDAE dae;
   BackendDAE.BackendDAE initdae;
-  BackendDAE.BackendDAE initdae0;
   BackendDAE.EqSystem initsyst;
   BackendDAE.EqSystems systs;
   BackendDAE.EquationArray eqns, reeqns;
@@ -207,9 +204,6 @@ algorithm
 
     // solve system
     initdae := BackendDAEUtil.transformBackendDAE(initdae, SOME((BackendDAE.NO_INDEX_REDUCTION(), BackendDAE.EXACT())), NONE(), NONE());
-    if useHomotopy then
-      initdae0 := BackendDAEUtil.copyBackendDAE(initdae);
-    end if;
 
     // simplify system
     initOptModules := BackendDAEUtil.getInitOptModules(NONE());
@@ -224,16 +218,6 @@ algorithm
       end if;
     end if;
 
-    // compute system for lambda=0
-    if useHomotopy then
-      initdae0 := BackendDAEUtil.setFunctionTree(initdae0, BackendDAEUtil.getFunctions(initdae.shared));
-      initdae0 := BackendDAEUtil.postOptimizeDAE(initdae0, (replaceHomotopyWithSimplified, "replaceHomotopyWithSimplified")::initOptModules, matchingAlgorithm, daeHandler);
-      outInitDAE_lambda0 := SOME(initdae0);
-      initdae := BackendDAEUtil.setFunctionTree(initdae, BackendDAEUtil.getFunctions(initdae0.shared));
-    else
-      outInitDAE_lambda0 := NONE();
-    end if;
-
     // Remove the globalKnownVars for the initialization set again
     if not stringEq(Config.simCodeTarget(), "Cpp") then
       initdae.shared := BackendDAEUtil.setSharedGlobalKnownVars(initdae.shared, BackendVariable.emptyVars());
@@ -278,7 +262,6 @@ algorithm
     end if;
 
     outInitDAE := initdae;
-    outUseHomotopy := useHomotopy;
     outRemovedInitialEquations := removedEqns;
   else
     Error.addCompilerError("No system for the symbolic initialization was generated");
@@ -1136,13 +1119,9 @@ protected function preBalanceInitialSystem1 "author: lochel"
 algorithm
   (outVars, outEqs, outB, outDumpVars) := match (n, inB)
     local
-      list<Integer> row;
-      Boolean b, useHomotopy;
+      Boolean b;
       BackendDAE.Variables vars;
       BackendDAE.EquationArray eqs;
-      list<BackendDAE.Var> rvarlst;
-      BackendDAE.Var var;
-      DAE.ComponentRef cref;
       list<BackendDAE.Var> dumpVars;
 
     case (0, false)

Compiler/BackEnd/OpenTURNS.mo

@@ -80,15 +80,12 @@ public function generateOpenTURNSInterface "generates the dll and the python scr
   input Absyn.Program inProgram;
   input String templateFile "the filename to the template file (python script)";
   output String scriptFile "the name of the generated file";
-
-  protected
+protected
   String cname_str,fileNamePrefix,fileDir,cname_last_str;
   list<String> libs;
   BackendDAE.BackendDAE dae,strippedDae;
   SimCode.SimulationSettings simSettings;
   BackendDAE.BackendDAE initDAE;
-  Option<BackendDAE.BackendDAE> initDAE_lambda0;
-  Boolean useHomotopy "true if homotopy(...) is used during initialization";
   list<BackendDAE.Equation> removedInitialEquationLst;
 algorithm
   cname_str := Absyn.pathString(inPath);
@@ -110,13 +107,13 @@ algorithm
  // Strip correlation vector from dae to be able to compile (bug in OpenModelica with vectors of records )
   strippedDae := stripCorrelationFromDae(inDaelow);
 
-  (strippedDae, initDAE, _, useHomotopy, initDAE_lambda0, removedInitialEquationLst) := BackendDAEUtil.getSolvedSystem(strippedDae,"");
+  (strippedDae, initDAE, _, removedInitialEquationLst) := BackendDAEUtil.getSolvedSystem(strippedDae,"");
 
   //print("strippedDae :");
   //BackendDump.dump(strippedDae);
   _ := System.realtimeTock(ClockIndexes.RT_CLOCK_BACKEND); // Is this necessary?
 
-  (libs, fileDir, _, _) := SimCodeMain.generateModelCode(strippedDae, initDAE, NONE(), useHomotopy, initDAE_lambda0, removedInitialEquationLst,inProgram, inPath, cname_str, SOME(simSettings), Absyn.FUNCTIONARGS({}, {}));
+  (libs, fileDir, _, _) := SimCodeMain.generateModelCode(strippedDae, initDAE, NONE(), removedInitialEquationLst,inProgram, inPath, cname_str, SOME(simSettings), Absyn.FUNCTIONARGS({}, {}));
 
   //print("..compiling, fileNamePrefix = "+fileNamePrefix+"\n");
   CevalScript.compileModel(fileNamePrefix , libs);

Compiler/Main/Main.mo

@@ -593,15 +593,13 @@ protected
   BackendDAE.BackendDAE dlow;
   BackendDAE.BackendDAE initDAE;
   Option<BackendDAE.InlineData> inlineData;
-  Boolean useHomotopy "true if homotopy(...) is used during initialization";
-  Option<BackendDAE.BackendDAE> initDAE_lambda0;
   list<BackendDAE.Equation> removedInitialEquationLst;
 algorithm
   if Config.simulationCg() then
     info := BackendDAE.EXTRA_INFO(DAEUtil.daeDescription(dae), Absyn.pathString(inClassName));
     dlow := BackendDAECreate.lower(dae, inCache, inEnv, info);
-    (dlow, initDAE, inlineData, useHomotopy, initDAE_lambda0, removedInitialEquationLst) := BackendDAEUtil.getSolvedSystem(dlow, "");
-    simcodegen(dlow, initDAE, inlineData, useHomotopy, initDAE_lambda0, removedInitialEquationLst, inClassName, ap);
+    (dlow, initDAE, inlineData, removedInitialEquationLst) := BackendDAEUtil.getSolvedSystem(dlow, "");
+    simcodegen(dlow, initDAE, inlineData, removedInitialEquationLst, inClassName, ap);
   end if;
 end optimizeDae;
 
@@ -610,8 +608,6 @@ protected function simcodegen "
   input BackendDAE.BackendDAE inBackendDAE;
   input BackendDAE.BackendDAE inInitDAE;
   input Option<BackendDAE.InlineData> inInlineData;
-  input Boolean inUseHomotopy "true if homotopy(...) is used during initialization";
-  input Option<BackendDAE.BackendDAE> inInitDAE_lambda0;
   input list<BackendDAE.Equation> inRemovedInitialEquationLst;
   input Absyn.Path inClassName;
   input Absyn.Program inProgram;
@@ -632,7 +628,7 @@ algorithm
       SimCodeMain.createSimulationSettings(0.0, 1.0, 500, 1e-6, "dassl", "", "mat", ".*", "");
 
     System.realtimeTock(ClockIndexes.RT_CLOCK_BACKEND); // Is this necessary?
-    SimCodeMain.generateModelCode(inBackendDAE, inInitDAE, inInlineData, inUseHomotopy, inInitDAE_lambda0, inRemovedInitialEquationLst, inProgram, inClassName, cname, SOME(sim_settings), Absyn.FUNCTIONARGS({}, {}));
+    SimCodeMain.generateModelCode(inBackendDAE, inInitDAE, inInlineData, inRemovedInitialEquationLst, inProgram, inClassName, cname, SOME(sim_settings), Absyn.FUNCTIONARGS({}, {}));
 
     execStat("Codegen Done");
   end if;

Compiler/SimCode/HpcOmSimCodeMain.mo

@@ -67,8 +67,6 @@ public function createSimCode "
   Entry point to create SimCode from BackendDAE."
   input BackendDAE.BackendDAE inBackendDAE;
   input BackendDAE.BackendDAE inInitDAE;
-  input Boolean inUseHomotopy "true if homotopy(...) is used during initialization";
-  input Option<BackendDAE.BackendDAE> inInitDAE_lambda0;
   input list<BackendDAE.Equation> inRemovedInitialEquationLst;
   input Absyn.Path inClassName;
   input String filenamePrefix;
@@ -132,7 +130,7 @@ algorithm
       //Setup
       //-----
       (simCode,(lastEqMappingIdx,equationSccMapping)) =
-          SimCodeUtil.createSimCode( inBackendDAE, inInitDAE, NONE(), inUseHomotopy, inInitDAE_lambda0, inRemovedInitialEquationLst, inClassName, filenamePrefix, inString11, functions,
+          SimCodeUtil.createSimCode( inBackendDAE, inInitDAE, NONE(), inRemovedInitialEquationLst, inClassName, filenamePrefix, inString11, functions,
                                      externalFunctionIncludes, includeDirs, libs,libPaths,program, simSettingsOpt, recordDecls, literals, args );
 
       //get simCode-backendDAE mappings
@@ -187,7 +185,7 @@ algorithm
       //-----
       System.realtimeTick(ClockIndexes.RT_CLOCK_EXECSTAT_HPCOM_MODULES);
       (simCode,(lastEqMappingIdx,equationSccMapping)) =
-          SimCodeUtil.createSimCode( inBackendDAE, inInitDAE, NONE(), inUseHomotopy, inInitDAE_lambda0, inRemovedInitialEquationLst, inClassName, filenamePrefix, inString11, functions,
+          SimCodeUtil.createSimCode( inBackendDAE, inInitDAE, NONE(), inRemovedInitialEquationLst, inClassName, filenamePrefix, inString11, functions,
                                      externalFunctionIncludes, includeDirs, libs,libPaths,program, simSettingsOpt, recordDecls, literals, args );
 
       //get simCode-backendDAE mappings

Compiler/SimCode/SerializeModelInfo.mo

@@ -88,7 +88,6 @@ algorithm
         File.write(file,"{\"eqIndex\":0,\"tag\":\"dummy\"}");
         min(serializeEquation(file,eq,"initial",withOperations) for eq in SimCodeUtil.sortEqSystems(code.initialEquations));
         min(serializeEquation(file,eq,"removed-initial",withOperations) for eq in SimCodeUtil.sortEqSystems(code.removedInitialEquations));
-        min(serializeEquation(file,eq,"initial-lambda0",withOperations) for eq in SimCodeUtil.sortEqSystems(code.initialEquations_lambda0));
         min(serializeEquation(file,eq,"regular",withOperations) for eq in SimCodeUtil.sortEqSystems(code.allEquations));
         min(serializeEquation(file,eq,"synchronous",withOperations) for eq in SimCodeUtil.sortEqSystems(SimCodeUtil.getClockedEquations(SimCodeUtil.getSubPartitions(code.clockedPartitions))));
         min(serializeEquation(file,eq,"start",withOperations) for eq in SimCodeUtil.sortEqSystems(code.startValueEquations));

Compiler/SimCode/SimCode.mo

@@ -108,9 +108,7 @@ uniontype SimCode
     list<list<SimEqSystem>> odeEquations;
     list<list<SimEqSystem>> algebraicEquations;
     list<ClockedPartition> clockedPartitions;
-    Boolean useHomotopy "true if homotopy(...) is used during initialization";
     list<SimEqSystem> initialEquations;
-    list<SimEqSystem> initialEquations_lambda0;
     list<SimEqSystem> removedInitialEquations;
     list<SimEqSystem> startValueEquations;
     list<SimEqSystem> nominalValueEquations;