OMCompiler/Compiler/Util/Flags.mo
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * This file is part of OpenModelica. | ||
| 3 | * | ||
| 4 | * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC), | ||
| 5 | * c/o Linköpings universitet, Department of Computer and Information Science, | ||
| 6 | * SE-58183 Linköping, Sweden. | ||
| 7 | * | ||
| 8 | * All rights reserved. | ||
| 9 | * | ||
| 10 | * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF AGPL VERSION 3 LICENSE OR | ||
| 11 | * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8. | ||
| 12 | * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES | ||
| 13 | * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GNU AGPL | ||
| 14 | * VERSION 3, ACCORDING TO RECIPIENTS CHOICE. | ||
| 15 | * | ||
| 16 | * The OpenModelica software and the OSMC (Open Source Modelica Consortium) | ||
| 17 | * Public License (OSMC-PL) are obtained from OSMC, either from the above | ||
| 18 | * address, from the URLs: | ||
| 19 | * http://www.openmodelica.org or | ||
| 20 | * https://github.com/OpenModelica/ or | ||
| 21 | * http://www.ida.liu.se/projects/OpenModelica, | ||
| 22 | * and in the OpenModelica distribution. | ||
| 23 | * | ||
| 24 | * GNU AGPL version 3 is obtained from: | ||
| 25 | * https://www.gnu.org/licenses/licenses.html#GPL | ||
| 26 | * | ||
| 27 | * This program is distributed WITHOUT ANY WARRANTY; without | ||
| 28 | * even the implied warranty of MERCHANTABILITY or FITNESS | ||
| 29 | * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH | ||
| 30 | * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL. | ||
| 31 | * | ||
| 32 | * See the full OSMC Public License conditions for more details. | ||
| 33 | * | ||
| 34 | */ | ||
| 35 | |||
| 36 | encapsulated package Flags | ||
| 37 | " file: Flags.mo | ||
| 38 | package: Flags | ||
| 39 | description: Tools for using compiler flags. | ||
| 40 | |||
| 41 | This package contains function for using compiler flags. There are two types | ||
| 42 | of flags, debug flag and configuration flags. The flags are stored and | ||
| 43 | retrieved with set/getGlobalRoot so that they can be accessed everywhere in | ||
| 44 | the compiler. | ||
| 45 | |||
| 46 | Configuration flags are flags such as --std which affects the behaviour of the | ||
| 47 | compiler. These flags can have different types, see the FlagData uniontype | ||
| 48 | below, and they also have a default value. There is also another package, | ||
| 49 | Config, which acts as a wrapper for many of these flags. | ||
| 50 | |||
| 51 | Debug flags are boolean flags specified with -d, which can be used together | ||
| 52 | with the Debug package. They are typically used to enable printing of extra | ||
| 53 | information that helps debugging, such as the failtrace flag. Unlike | ||
| 54 | configuration flags they are only on or off, i.e. true or false. | ||
| 55 | |||
| 56 | To add a new flag, simply add a new constant of either DebugFlag or ConfigFlag | ||
| 57 | type below, and then add it to either the allDebugFlags or allConfigFlags list | ||
| 58 | (in FlagsUtil.mo), depending on which type it is. | ||
| 59 | " | ||
| 60 | |||
| 61 | public | ||
| 62 | protected | ||
| 63 | import Global; | ||
| 64 | |||
| 65 | public uniontype DebugFlag | ||
| 66 | record DEBUG_FLAG | ||
| 67 | Integer index "Unique index."; | ||
| 68 | String name "The name of the flag used by -d"; | ||
| 69 | Boolean default "Default enabled or not"; | ||
| 70 | String description "A description of the flag."; | ||
| 71 | end DEBUG_FLAG; | ||
| 72 | end DebugFlag; | ||
| 73 | |||
| 74 | public uniontype ConfigFlag | ||
| 75 | record CONFIG_FLAG | ||
| 76 | Integer index "Unique index."; | ||
| 77 | String name "The whole name of the flag."; | ||
| 78 | Option<String> shortname "A short name one-character name for the flag."; | ||
| 79 | FlagVisibility visibility "Whether the flag is visible to the user or not."; | ||
| 80 | FlagData defaultValue "The default value of the flag."; | ||
| 81 | Option<ValidOptions> validOptions "The valid options for the flag."; | ||
| 82 | String description "A description of the flag."; | ||
| 83 | end CONFIG_FLAG; | ||
| 84 | end ConfigFlag; | ||
| 85 | |||
| 86 | public uniontype FlagData | ||
| 87 | "This uniontype is used to store the values of configuration flags." | ||
| 88 | |||
| 89 | record EMPTY_FLAG | ||
| 90 | "Only used to initialize the flag array." | ||
| 91 | end EMPTY_FLAG; | ||
| 92 | |||
| 93 | record BOOL_FLAG | ||
| 94 | Boolean data "Value of a boolean flag."; | ||
| 95 | end BOOL_FLAG; | ||
| 96 | |||
| 97 | record INT_FLAG | ||
| 98 | Integer data "Value of an integer flag."; | ||
| 99 | end INT_FLAG; | ||
| 100 | |||
| 101 | record INT_LIST_FLAG | ||
| 102 | list<Integer> data "Value of an integer flag that can have multiple values."; | ||
| 103 | end INT_LIST_FLAG; | ||
| 104 | |||
| 105 | record REAL_FLAG | ||
| 106 | Real data "Value of a real flag."; | ||
| 107 | end REAL_FLAG; | ||
| 108 | |||
| 109 | record STRING_FLAG | ||
| 110 | String data "Value of a string flag."; | ||
| 111 | end STRING_FLAG; | ||
| 112 | |||
| 113 | record STRING_LIST_FLAG | ||
| 114 | list<String> data "Values of a string flag that can have multiple values."; | ||
| 115 | end STRING_LIST_FLAG; | ||
| 116 | |||
| 117 | record ENUM_FLAG | ||
| 118 | Integer data "Value of an enumeration flag."; | ||
| 119 | list<tuple<String, Integer>> validValues "The valid values of the enum."; | ||
| 120 | end ENUM_FLAG; | ||
| 121 | end FlagData; | ||
| 122 | |||
| 123 | public uniontype FlagVisibility | ||
| 124 | "This uniontype is used to specify the visibility of a configuration flag." | ||
| 125 | record INTERNAL "An internal flag that is hidden to the user." end INTERNAL; | ||
| 126 | record EXTERNAL "An external flag that is visible to the user." end EXTERNAL; | ||
| 127 | end FlagVisibility; | ||
| 128 | |||
| 129 | public uniontype Flag | ||
| 130 | "The structure which stores the flags." | ||
| 131 | record FLAGS | ||
| 132 | array<Boolean> debugFlags; | ||
| 133 | array<FlagData> configFlags; | ||
| 134 | end FLAGS; | ||
| 135 | |||
| 136 | record NO_FLAGS end NO_FLAGS; | ||
| 137 | end Flag; | ||
| 138 | |||
| 139 | public uniontype ValidOptions | ||
| 140 | "Specifies valid options for a flag." | ||
| 141 | |||
| 142 | record STRING_OPTION | ||
| 143 | list<String> options "Options for a string flag."; | ||
| 144 | end STRING_OPTION; | ||
| 145 | |||
| 146 | record STRING_DESC_OPTION | ||
| 147 | list<tuple<String, String>> options | ||
| 148 | "Options for a string flag, with a description for each option."; | ||
| 149 | end STRING_DESC_OPTION; | ||
| 150 | end ValidOptions; | ||
| 151 | |||
| 152 | // Change this to a proper enum when we have support for them. | ||
| 153 | public constant Integer MODELICA = 1; | ||
| 154 | public constant Integer METAMODELICA = 2; | ||
| 155 | public constant Integer PARMODELICA = 3; | ||
| 156 | public constant Integer OPTIMICA = 4; | ||
| 157 | public constant Integer PDEMODELICA = 5; | ||
| 158 | |||
| 159 | // FMI-ModelDescription-ENUM-FLAGS | ||
| 160 | public constant Integer FMI_NONE = 1; | ||
| 161 | public constant Integer FMI_INTERNAL = 2; | ||
| 162 | public constant Integer FMI_PROTECTED = 3; | ||
| 163 | public constant Integer FMI_BLACKBOX = 4; | ||
| 164 | |||
| 165 | // How much source code an FMU carries, see FMI_SOURCES | ||
| 166 | public constant Integer FMI_SOURCES_NONE = 1; | ||
| 167 | public constant Integer FMI_SOURCES_SLIM = 2; | ||
| 168 | public constant Integer FMI_SOURCES_FULL = 3; | ||
| 169 | |||
| 170 | // FMI version enum flags | ||
| 171 | public constant Integer FMI_VERSION_10 = 10; | ||
| 172 | public constant Integer FMI_VERSION_20 = 20; | ||
| 173 | public constant Integer FMI_VERSION_30 = 30; | ||
| 174 | |||
| 175 | constant String collapseArrayExpressionsText = "Simplifies {x[1],x[2],x[3]} → x for arrays of whole variable references (simplifies code generation)."; | ||
| 176 | |||
| 177 | // DEBUG FLAGS | ||
| 178 | public | ||
| 179 | constant DebugFlag FAILTRACE = DEBUG_FLAG(1, "failtrace", false, | ||
| 180 | "Sets whether to print a failtrace or not."); | ||
| 181 | constant DebugFlag CEVAL = DEBUG_FLAG(2, "ceval", false, | ||
| 182 | "Prints extra information from Ceval."); | ||
| 183 | constant DebugFlag CHECK_BACKEND_DAE = DEBUG_FLAG(3, "checkBackendDae", false, | ||
| 184 | "Do some simple analyses on the datastructure from the frontend to check if it is consistent."); | ||
| 185 | constant DebugFlag PTHREADS = DEBUG_FLAG(4, "pthreads", false, | ||
| 186 | "Experimental: Unused parallelization."); | ||
| 187 | constant DebugFlag EVENTS = DEBUG_FLAG(5, "events", true, | ||
| 188 | "Turns on/off events handling."); | ||
| 189 | constant DebugFlag DUMP_INLINE_SOLVER = DEBUG_FLAG(6, "dumpInlineSolver", false, | ||
| 190 | "Dumps the inline solver equation system."); | ||
| 191 | constant DebugFlag EVAL_FUNC = DEBUG_FLAG(7, "evalfunc", true, | ||
| 192 | "Turns on/off symbolic function evaluation."); | ||
| 193 | constant DebugFlag GEN = DEBUG_FLAG(8, "gen", false, | ||
| 194 | "Turns on/off dynamic loading of functions that are compiled during translation. Only enable this if external functions are needed to calculate structural parameters or constants."); | ||
| 195 | constant DebugFlag DYN_LOAD = DEBUG_FLAG(9, "dynload", false, | ||
| 196 | "Display debug information about dynamic loading of compiled functions."); | ||
| 197 | constant DebugFlag GENERATE_CODE_CHEAT = DEBUG_FLAG(10, "generateCodeCheat", false, | ||
| 198 | "Used to generate code for the bootstrapped compiler."); | ||
| 199 | constant DebugFlag CGRAPH_GRAPHVIZ_FILE = DEBUG_FLAG(11, "cgraphGraphVizFile", false, | ||
| 200 | "Generates a graphviz file of the connection graph."); | ||
| 201 | constant DebugFlag CGRAPH_GRAPHVIZ_SHOW = DEBUG_FLAG(12, "cgraphGraphVizShow", false, | ||
| 202 | "Displays the connection graph with the GraphViz lefty tool."); | ||
| 203 | constant DebugFlag GC_PROF = DEBUG_FLAG(13, "gcProfiling", false, | ||
| 204 | "Prints garbage collection stats to standard output."); | ||
| 205 | constant DebugFlag CHECK_DAE_CREF_TYPE = DEBUG_FLAG(14, "checkDAECrefType", false, | ||
| 206 | "Enables extra type checking for cref expressions."); | ||
| 207 | constant DebugFlag CHECK_ASUB = DEBUG_FLAG(15, "checkASUB", false, | ||
| 208 | "Prints out a warning if an ASUB is created from a CREF expression."); | ||
| 209 | constant DebugFlag INSTANCE = DEBUG_FLAG(16, "instance", false, | ||
| 210 | "Prints extra failtrace from InstanceHierarchy."); | ||
| 211 | constant DebugFlag CACHE = DEBUG_FLAG(17, "Cache", true, | ||
| 212 | "Turns off the instantiation cache."); | ||
| 213 | constant DebugFlag RML = DEBUG_FLAG(18, "rml", false, | ||
| 214 | "Converts Modelica-style arrays to lists."); | ||
| 215 | constant DebugFlag TAIL = DEBUG_FLAG(19, "tail", false, | ||
| 216 | "Prints out a notification if tail recursion optimization has been applied."); | ||
| 217 | constant DebugFlag LOOKUP = DEBUG_FLAG(20, "lookup", false, | ||
| 218 | "Print extra failtrace from lookup."); | ||
| 219 | constant DebugFlag PATTERNM_SKIP_FILTER_UNUSED_AS_BINDINGS = DEBUG_FLAG(21, "patternmSkipFilterUnusedBindings", false, | ||
| 220 | ""); | ||
| 221 | constant DebugFlag PATTERNM_ALL_INFO = DEBUG_FLAG(22, "patternmAllInfo", false, | ||
| 222 | "Adds notifications of all pattern-matching optimizations that are performed."); | ||
| 223 | constant DebugFlag PATTERNM_DCE = DEBUG_FLAG(23, "patternmDeadCodeElimination", true, | ||
| 224 | "Performs dead code elimination in match-expressions."); | ||
| 225 | constant DebugFlag PATTERNM_MOVE_LAST_EXP = DEBUG_FLAG(24, "patternmMoveLastExp", true, | ||
| 226 | "Optimization that moves the last assignment(s) into the result of a match-expression. For example: equation c = fn(b); then c; => then fn(b);"); | ||
| 227 | constant DebugFlag EXPERIMENTAL_REDUCTIONS = DEBUG_FLAG(25, "experimentalReductions", false, | ||
| 228 | "Turns on custom reduction functions (OpenModelica extension)."); | ||
| 229 | constant DebugFlag EVAL_PARAM = DEBUG_FLAG(26, "evaluateAllParameters", false, | ||
| 230 | "Evaluates all parameters if set, except the ones that have annotation(Evaluate = false)."); | ||
| 231 | constant DebugFlag TYPES = DEBUG_FLAG(27, "types", false, | ||
| 232 | "Prints extra failtrace from Types."); | ||
| 233 | constant DebugFlag SHOW_STATEMENT = DEBUG_FLAG(28, "showStatement", false, | ||
| 234 | "Shows the statement that is currently being evaluated when evaluating a script."); | ||
| 235 | constant DebugFlag DUMP = DEBUG_FLAG(29, "dump", false, | ||
| 236 | "Dumps the absyn representation of a program."); | ||
| 237 | constant DebugFlag DUMP_GRAPHVIZ = DEBUG_FLAG(30, "graphviz", false, | ||
| 238 | "Dumps the absyn representation of a program in graphviz format."); | ||
| 239 | constant DebugFlag EXEC_STAT = DEBUG_FLAG(31, "execstat", false, | ||
| 240 | "Prints out execution statistics for the compiler."); | ||
| 241 | constant DebugFlag TRANSFORMS_BEFORE_DUMP = DEBUG_FLAG(32, "transformsbeforedump", false, | ||
| 242 | "Applies transformations required for code generation before dumping flat code."); | ||
| 243 | constant DebugFlag DAE_DUMP_GRAPHV = DEBUG_FLAG(33, "daedumpgraphv", false, | ||
| 244 | "Dumps the DAE in graphviz format."); | ||
| 245 | constant DebugFlag INTERACTIVE_TCP = DEBUG_FLAG(34, "interactive", false, | ||
| 246 | "Starts omc as a server listening on the socket interface."); | ||
| 247 | constant DebugFlag INTERACTIVE_DUMP = DEBUG_FLAG(35, "interactivedump", false, | ||
| 248 | "Prints out debug information for the interactive server."); | ||
| 249 | constant DebugFlag RELIDX = DEBUG_FLAG(36, "relidx", false, | ||
| 250 | "Prints out debug information about relations, that are used as zero crossings."); | ||
| 251 | constant DebugFlag DUMP_REPL = DEBUG_FLAG(37, "dumprepl", false, | ||
| 252 | "Dump the found replacements for simple equation removal."); | ||
| 253 | constant DebugFlag DUMP_FP_REPL = DEBUG_FLAG(38, "dumpFPrepl", false, | ||
| 254 | "Dump the found replacements for final parameters."); | ||
| 255 | constant DebugFlag DUMP_PARAM_REPL = DEBUG_FLAG(39, "dumpParamrepl", false, | ||
| 256 | "Dump the found replacements for remove parameters."); | ||
| 257 | constant DebugFlag DUMP_PP_REPL = DEBUG_FLAG(40, "dumpPPrepl", false, | ||
| 258 | "Dump the found replacements for protected parameters."); | ||
| 259 | constant DebugFlag DUMP_EA_REPL = DEBUG_FLAG(41, "dumpEArepl", false, | ||
| 260 | "Dump the found replacements for evaluate annotations (evaluate=true) parameters."); | ||
| 261 | constant DebugFlag DEBUG_ALIAS = DEBUG_FLAG(42, "debugAlias", false, | ||
| 262 | "Dumps some information about the process of removeSimpleEquations."); | ||
| 263 | constant DebugFlag TEARING_DUMP = DEBUG_FLAG(43, "tearingdump", false, | ||
| 264 | "Dumps tearing information."); | ||
| 265 | constant DebugFlag JAC_DUMP = DEBUG_FLAG(44, "symjacdump", false, | ||
| 266 | "Dumps information about symbolic Jacobians."); | ||
| 267 | constant DebugFlag JAC_DUMP2 = DEBUG_FLAG(45, "symjacdumpverbose", false, | ||
| 268 | "Dumps information in verbose mode about symbolic Jacobians."); | ||
| 269 | constant DebugFlag DUMP_BINDINGS = DEBUG_FLAG(46, "dumpBindings", false, | ||
| 270 | "Dumps information about the equations created from bindings."); | ||
| 271 | constant DebugFlag DUMP_SORTING = DEBUG_FLAG(47, "dumpSorting", false, | ||
| 272 | "Dumps information about the process of sorting."); | ||
| 273 | constant DebugFlag DUMP_SPARSE = DEBUG_FLAG(48, "dumpSparsePattern", false, | ||
| 274 | "Dumps sparse pattern with coloring used for simulation."); | ||
| 275 | constant DebugFlag DUMP_SPARSE_VERBOSE = DEBUG_FLAG(49, "dumpSparsePatternVerbose", false, | ||
| 276 | "Dumps in verbose mode sparse pattern with coloring used for simulation."); | ||
| 277 | constant DebugFlag BLT_DUMP = DEBUG_FLAG(50, "bltdump", false, | ||
| 278 | "Dumps information from index reduction."); | ||
| 279 | constant DebugFlag DUMMY_SELECT = DEBUG_FLAG(51, "dummyselect", false, | ||
| 280 | "Dumps information from dummy state selection heuristic."); | ||
| 281 | constant DebugFlag DUMP_DAE_LOW = DEBUG_FLAG(52, "dumpdaelow", false, | ||
| 282 | "Dumps the equation system at the beginning of the back end."); | ||
| 283 | constant DebugFlag DUMP_INDX_DAE = DEBUG_FLAG(53, "dumpindxdae", false, | ||
| 284 | "Dumps the equation system after index reduction and optimization."); | ||
| 285 | constant DebugFlag OPT_DAE_DUMP = DEBUG_FLAG(54, "optdaedump", false, | ||
| 286 | "Dumps information from the optimization modules."); | ||
| 287 | constant DebugFlag EXEC_HASH = DEBUG_FLAG(55, "execHash", false, | ||
| 288 | "Measures the time it takes to hash all simcode variables before code generation."); | ||
| 289 | constant DebugFlag PARAM_DLOW_DUMP = DEBUG_FLAG(56, "paramdlowdump", false, | ||
| 290 | "Enables dumping of the parameters in the order they are calculated."); | ||
| 291 | constant DebugFlag DUMP_ENCAPSULATECONDITIONS = DEBUG_FLAG(57, "dumpEncapsulateConditions", false, | ||
| 292 | "Dumps the results of the preOptModule encapsulateWhenConditions."); | ||
| 293 | constant DebugFlag SHORT_OUTPUT = DEBUG_FLAG(58, "shortOutput", false, | ||
| 294 | "Enables short output of the simulate() command. Useful for tools like OMNotebook."); | ||
| 295 | constant DebugFlag COUNT_OPERATIONS = DEBUG_FLAG(59, "countOperations", false, | ||
| 296 | "Count operations."); | ||
| 297 | constant DebugFlag CGRAPH = DEBUG_FLAG(60, "cgraph", false, | ||
| 298 | "Prints out connection graph information."); | ||
| 299 | constant DebugFlag UPDMOD = DEBUG_FLAG(61, "updmod", false, | ||
| 300 | "Prints information about modification updates."); | ||
| 301 | constant DebugFlag STATIC = DEBUG_FLAG(62, "static", false, | ||
| 302 | "Enables extra debug output from the static elaboration."); | ||
| 303 | constant DebugFlag TPL_PERF_TIMES = DEBUG_FLAG(63, "tplPerfTimes", false, | ||
| 304 | "Enables output of template performance data for rendering text to file."); | ||
| 305 | constant DebugFlag CHECK_SIMPLIFY = DEBUG_FLAG(64, "checkSimplify", false, | ||
| 306 | "Enables checks for expression simplification and prints a notification whenever an undesirable transformation has been performed."); | ||
| 307 | constant DebugFlag SCODE_INST = DEBUG_FLAG(65, "newInst", true, | ||
| 308 | "Enables new instantiation phase."); | ||
| 309 | constant DebugFlag WRITE_TO_BUFFER = DEBUG_FLAG(66, "writeToBuffer", false, | ||
| 310 | "Enables writing simulation results to buffer."); | ||
| 311 | constant DebugFlag DUMP_BACKENDDAE_INFO = DEBUG_FLAG(67, "backenddaeinfo", false, | ||
| 312 | "Enables dumping of back-end information about system (Number of equations before back-end,...)."); | ||
| 313 | constant DebugFlag GEN_DEBUG_SYMBOLS = DEBUG_FLAG(68, "gendebugsymbols", false, | ||
| 314 | "Generate code with debugging symbols."); | ||
| 315 | constant DebugFlag DUMP_STATESELECTION_INFO = DEBUG_FLAG(69, "stateselection", false, | ||
| 316 | "Enables dumping of selected states. Extends -d=backenddaeinfo."); | ||
| 317 | constant DebugFlag DUMP_EQNINORDER = DEBUG_FLAG(70, "dumpeqninorder", false, | ||
| 318 | "Enables dumping of the equations in the order they are calculated."); | ||
| 319 | constant DebugFlag SEMILINEAR = DEBUG_FLAG(71, "semiLinear", false, | ||
| 320 | "Enables dumping of the optimization information when optimizing calls to semiLinear."); | ||
| 321 | constant DebugFlag UNCERTAINTIES = DEBUG_FLAG(72, "uncertainties", false, | ||
| 322 | "Enables dumping of status when calling modelEquationsUC."); | ||
| 323 | constant DebugFlag SHOW_START_ORIGIN = DEBUG_FLAG(73, "showStartOrigin", false, | ||
| 324 | "Enables dumping of the DAE startOrigin attribute of the variables."); | ||
| 325 | constant DebugFlag DUMP_SIMCODE = DEBUG_FLAG(74, "dumpSimCode", false, | ||
| 326 | "Dumps the simCode model used for code generation."); | ||
| 327 | constant DebugFlag DUMP_INITIAL_SYSTEM = DEBUG_FLAG(75, "dumpinitialsystem", false, | ||
| 328 | "Dumps the initial equation system."); | ||
| 329 | constant DebugFlag GRAPH_INST = DEBUG_FLAG(76, "graphInst", false, | ||
| 330 | "Do graph based instantiation."); | ||
| 331 | constant DebugFlag GRAPH_INST_RUN_DEP = DEBUG_FLAG(77, "graphInstRunDep", false, | ||
| 332 | "Run scode dependency analysis. Use with -d=graphInst"); | ||
| 333 | constant DebugFlag GRAPH_INST_GEN_GRAPH = DEBUG_FLAG(78, "graphInstGenGraph", false, | ||
| 334 | "Dumps a graph of the program. Use with -d=graphInst"); | ||
| 335 | constant DebugFlag DUMP_CONST_REPL = DEBUG_FLAG(79, "dumpConstrepl", false, | ||
| 336 | "Dump the found replacements for constants."); | ||
| 337 | constant DebugFlag SHOW_EQUATION_SOURCE = DEBUG_FLAG(80, "showEquationSource", false, | ||
| 338 | "Display the element source information in the dumped DAE for easier debugging."); | ||
| 339 | constant DebugFlag LS_ANALYTIC_JACOBIAN = DEBUG_FLAG(81, "LSanalyticJacobian", false, | ||
| 340 | "Enables analytical jacobian for linear strong components. Defaults to false"); | ||
| 341 | constant DebugFlag NLS_ANALYTIC_JACOBIAN = DEBUG_FLAG(82, "NLSanalyticJacobian", true, | ||
| 342 | "Enables analytical jacobian for non-linear strong components without user-defined function calls, for that see forceNLSanalyticJacobian"); | ||
| 343 | constant DebugFlag INLINE_SOLVER = DEBUG_FLAG(83, "inlineSolver", false, | ||
| 344 | "Generates code for inline solver."); | ||
| 345 | constant DebugFlag HPCOM = DEBUG_FLAG(84, "hpcom", false, | ||
| 346 | "Enables parallel calculation based on task-graphs."); | ||
| 347 | constant DebugFlag INITIALIZATION = DEBUG_FLAG(85, "initialization", false, | ||
| 348 | "Shows additional information from the initialization process."); | ||
| 349 | constant DebugFlag INLINE_FUNCTIONS = DEBUG_FLAG(86, "inlineFunctions", true, | ||
| 350 | "Controls if function inlining should be performed."); | ||
| 351 | constant DebugFlag DUMP_SCC_GRAPHML = DEBUG_FLAG(87, "dumpSCCGraphML", false, | ||
| 352 | "Dumps graphml files with the strongly connected components."); | ||
| 353 | constant DebugFlag TEARING_DUMPVERBOSE = DEBUG_FLAG(88, "tearingdumpV", false, | ||
| 354 | "Dumps verbose tearing information."); | ||
| 355 | constant DebugFlag DISABLE_SINGLE_FLOW_EQ = DEBUG_FLAG(89, "disableSingleFlowEq", false, | ||
| 356 | "Disables the generation of single flow equations."); | ||
| 357 | constant DebugFlag DUMP_DISCRETEVARS_INFO = DEBUG_FLAG(90, "discreteinfo", false, | ||
| 358 | "Enables dumping of discrete variables. Extends -d=backenddaeinfo."); | ||
| 359 | constant DebugFlag ADDITIONAL_GRAPHVIZ_DUMP = DEBUG_FLAG(91, "graphvizDump", false, | ||
| 360 | "Activates additional graphviz dumps (as .dot files). It can be used in addition to one of the following flags: {dumpdaelow|dumpinitialsystems|dumpindxdae}."); | ||
| 361 | constant DebugFlag INFO_XML_OPERATIONS = DEBUG_FLAG(92, "infoXmlOperations", false, | ||
| 362 | "Enables output of the operations in the _info.xml file when translating models."); | ||
| 363 | constant DebugFlag HPCOM_DUMP = DEBUG_FLAG(93, "hpcomDump", false, | ||
| 364 | "Dumps additional information on the parallel execution with hpcom."); | ||
| 365 | constant DebugFlag RESOLVE_LOOPS_DUMP = DEBUG_FLAG(94, "resolveLoopsDump", false, | ||
| 366 | "Debug Output for ResolveLoops Module."); | ||
| 367 | constant DebugFlag DISABLE_WINDOWS_PATH_CHECK_WARNING = DEBUG_FLAG(95, "disableWindowsPathCheckWarning", false, | ||
| 368 | "Disables warnings on Windows if OPENMODELICAHOME/MinGW is missing."); | ||
| 369 | constant DebugFlag DISABLE_RECORD_CONSTRUCTOR_OUTPUT = DEBUG_FLAG(96, "disableRecordConstructorOutput", false, | ||
| 370 | "Disables output of record constructors in the flat code."); | ||
| 371 | constant DebugFlag IMPL_ODE = DEBUG_FLAG(97, "implOde", false, | ||
| 372 | "activates implicit codegen"); | ||
| 373 | constant DebugFlag EVAL_FUNC_DUMP = DEBUG_FLAG(98, "evalFuncDump", false, | ||
| 374 | "dumps debug information about the function evaluation"); | ||
| 375 | constant DebugFlag PRINT_STRUCTURAL = DEBUG_FLAG(99, "printStructuralParameters", false, | ||
| 376 | "Prints the structural parameters identified by the front-end"); | ||
| 377 | constant DebugFlag ITERATION_VARS = DEBUG_FLAG(100, "iterationVars", false, | ||
| 378 | "Shows a list of all iteration variables."); | ||
| 379 | constant DebugFlag ALLOW_RECORD_TOO_MANY_FIELDS = DEBUG_FLAG(101, "acceptTooManyFields", false, | ||
| 380 | "Accepts passing records with more fields than expected to a function. This is not allowed, but is used in Fluid.Dissipation. See https://trac.modelica.org/Modelica/ticket/1245 for details."); | ||
| 381 | constant DebugFlag HPCOM_MEMORY_OPT = DEBUG_FLAG(102, "hpcomMemoryOpt", false, | ||
| 382 | "Optimize the memory structure regarding the selected scheduler"); | ||
| 383 | constant DebugFlag DUMP_SYNCHRONOUS = DEBUG_FLAG(103, "dumpSynchronous", false, | ||
| 384 | "Dumps information of the clock partitioning."); | ||
| 385 | constant DebugFlag STRIP_PREFIX = DEBUG_FLAG(104, "stripPrefix", true, | ||
| 386 | "Strips the environment prefix from path/crefs. Defaults to true."); | ||
| 387 | constant DebugFlag DO_SCODE_DEP = DEBUG_FLAG(105, "scodeDep", true, | ||
| 388 | "Does scode dependency analysis prior to instantiation. Defaults to true."); | ||
| 389 | constant DebugFlag SHOW_INST_CACHE_INFO = DEBUG_FLAG(106, "showInstCacheInfo", false, | ||
| 390 | "Prints information about instantiation cache hits and additions. Defaults to false."); | ||
| 391 | constant DebugFlag DUMP_UNIT = DEBUG_FLAG(107, "dumpUnits", false, | ||
| 392 | "Dumps all the calculated units."); | ||
| 393 | constant DebugFlag DUMP_EQ_UNIT = DEBUG_FLAG(108, "dumpEqInUC", false, | ||
| 394 | "Dumps all equations handled by the unit checker."); | ||
| 395 | constant DebugFlag DUMP_EQ_UNIT_STRUCT = DEBUG_FLAG(109, "dumpEqUCStruct", false, | ||
| 396 | "Dumps all the equations handled by the unit checker as tree-structure."); | ||
| 397 | constant DebugFlag SHOW_DAE_GENERATION = DEBUG_FLAG(110, "showDaeGeneration", false, | ||
| 398 | "Show the dae variable declarations as they happen."); | ||
| 399 | constant DebugFlag RESHUFFLE_POST = DEBUG_FLAG(111, "reshufflePost", false, | ||
| 400 | "Reshuffles the systems of equations."); | ||
| 401 | constant DebugFlag SHOW_EXPANDABLE_INFO = DEBUG_FLAG(112, "showExpandableInfo", false, | ||
| 402 | "Show information about expandable connector handling."); | ||
| 403 | constant DebugFlag DUMP_HOMOTOPY = DEBUG_FLAG(113, "dumpHomotopy", false, | ||
| 404 | "Dumps the results of the postOptModule optimizeHomotopyCalls."); | ||
| 405 | constant DebugFlag OMC_RELOCATABLE_FUNCTIONS = DEBUG_FLAG(114, "relocatableFunctions", false, | ||
| 406 | "Generates relocatable code: all functions become function pointers and can be replaced at run-time."); | ||
| 407 | constant DebugFlag GRAPHML = DEBUG_FLAG(115, "graphml", false, | ||
| 408 | "Dumps .graphml files for the bipartite graph after Index Reduction and a task graph for the SCCs. Can be displayed with yEd. "); | ||
| 409 | constant DebugFlag USEMPI = DEBUG_FLAG(116, "useMPI", false, | ||
| 410 | "Add MPI init and finalize to main method (CPPruntime). "); | ||
| 411 | constant DebugFlag DUMP_CSE = DEBUG_FLAG(117, "dumpCSE", false, | ||
| 412 | "Additional output for CSE module."); | ||
| 413 | constant DebugFlag DUMP_CSE_VERBOSE = DEBUG_FLAG(118, "dumpCSE_verbose", false, | ||
| 414 | "Additional output for CSE module."); | ||
| 415 | constant DebugFlag NO_START_CALC = DEBUG_FLAG(119, "disableStartCalc", false, | ||
| 416 | "Deactivates the pre-calculation of start values during compile-time."); | ||
| 417 | constant DebugFlag CONSTJAC = DEBUG_FLAG(120, "constjac", false, | ||
| 418 | "solves linear systems with constant Jacobian and variable b-Vector symbolically"); | ||
| 419 | constant DebugFlag VISUAL_XML = DEBUG_FLAG(121, "visxml", false, | ||
| 420 | "Outputs a xml-file that contains information for visualization."); | ||
| 421 | constant DebugFlag VECTORIZE = DEBUG_FLAG(122, "vectorize", false, | ||
| 422 | "Activates vectorization in the backend."); | ||
| 423 | constant DebugFlag CHECK_EXT_LIBS = DEBUG_FLAG(123, "buildExternalLibs", true, | ||
| 424 | "Use the autotools project in the Resources folder of the library to build missing external libraries."); | ||
| 425 | constant DebugFlag RUNTIME_STATIC_LINKING = DEBUG_FLAG(124, "runtimeStaticLinking", false, | ||
| 426 | "Use the static simulation runtime libraries (C++ simulation runtime)."); | ||
| 427 | constant DebugFlag SORT_EQNS_AND_VARS = DEBUG_FLAG(125, "dumpSortEqnsAndVars", false, | ||
| 428 | "Dumps debug output for the modules sortEqnsVars."); | ||
| 429 | constant DebugFlag DUMP_SIMPLIFY_LOOPS = DEBUG_FLAG(126, "dumpSimplifyLoops", false, | ||
| 430 | "Dump between steps of simplifyLoops"); | ||
| 431 | constant DebugFlag DUMP_RTEARING = DEBUG_FLAG(127, "dumpRecursiveTearing", false, | ||
| 432 | "Dump between steps of recursiveTearing"); | ||
| 433 | constant DebugFlag DIS_SYMJAC_FMI20 = DEBUG_FLAG(128, "disableDirectionalDerivatives", true, | ||
| 434 | "For FMI 2.0 only dependecy analysis will be perform."); | ||
| 435 | constant DebugFlag EVAL_OUTPUT_ONLY = DEBUG_FLAG(129, "evalOutputOnly", false, | ||
| 436 | "Generates equations to calculate top level outputs only."); | ||
| 437 | constant DebugFlag HARDCODED_START_VALUES = DEBUG_FLAG(130, "hardcodedStartValues", false, | ||
| 438 | "Embed the start values of variables and parameters into the c++ code and do not read it from xml file."); | ||
| 439 | constant DebugFlag DUMP_FUNCTIONS = DEBUG_FLAG(131, "dumpFunctions", false, | ||
| 440 | "Add functions to backend dumps."); | ||
| 441 | constant DebugFlag DEBUG_DIFFERENTIATION = DEBUG_FLAG(132, "debugDifferentiation", false, | ||
| 442 | "Dumps debug output for the differentiation process."); | ||
| 443 | constant DebugFlag DEBUG_DIFFERENTIATION_VERBOSE = DEBUG_FLAG(133, "debugDifferentiationVerbose", false, | ||
| 444 | "Dumps verbose debug output for the differentiation process."); | ||
| 445 | constant DebugFlag FMU_EXPERIMENTAL = DEBUG_FLAG(134, "fmuExperimental", false, | ||
| 446 | "Adds features to the FMI export that are considered experimental as of now: fmi2GetSpecificDerivatives, canGetSetFMUState, canSerializeFMUstate"); | ||
| 447 | constant DebugFlag DUMP_DGESV = DEBUG_FLAG(135, "dumpdgesv", false, | ||
| 448 | "Enables dumping of the information whether DGESV is used to solve linear systems."); | ||
| 449 | constant DebugFlag MULTIRATE_PARTITION = DEBUG_FLAG(136, "multirate", false, | ||
| 450 | "The solver can switch partitions in the system."); | ||
| 451 | constant DebugFlag DUMP_EXCLUDED_EXP = DEBUG_FLAG(137, "dumpExcludedSymJacExps", false, | ||
| 452 | "This flags dumps all expression that are excluded from differentiation of a symbolic Jacobian."); | ||
| 453 | constant DebugFlag DEBUG_ALGLOOP_JACOBIAN = DEBUG_FLAG(138, "debugAlgebraicLoopsJacobian", false, | ||
| 454 | "Dumps debug output while creating symbolic jacobians for non-linear systems."); | ||
| 455 | constant DebugFlag DISABLE_JACSCC = DEBUG_FLAG(139, "disableJacsforSCC", false, | ||
| 456 | "Disables calculation of jacobians to detect if a SCC is linear or non-linear. By disabling all SCC will handled like non-linear."); | ||
| 457 | constant DebugFlag FORCE_NLS_ANALYTIC_JACOBIAN = DEBUG_FLAG(140, "forceNLSanalyticJacobian", false, | ||
| 458 | "Forces calculation analytical jacobian also for non-linear strong components with user-defined functions."); | ||
| 459 | constant DebugFlag DUMP_LOOPS = DEBUG_FLAG(141, "dumpLoops", false, | ||
| 460 | "Dumps loop equation."); | ||
| 461 | constant DebugFlag DUMP_LOOPS_VERBOSE = DEBUG_FLAG(142, "dumpLoopsVerbose", false, | ||
| 462 | "Dumps loop equation and enhanced adjacency matrix."); | ||
| 463 | constant DebugFlag SKIP_INPUT_OUTPUT_SYNTACTIC_SUGAR = DEBUG_FLAG(143, "skipInputOutputSyntacticSugar", false, | ||
| 464 | "Used when bootstrapping to preserve the input output parsing of the code output by the list command."); | ||
| 465 | constant DebugFlag OMC_RECORD_ALLOC_WORDS = DEBUG_FLAG(144, "metaModelicaRecordAllocWords", false, | ||
| 466 | "Instrument the source code to record memory allocations (requires run-time and generated files compiled with -DOMC_RECORD_ALLOC_WORDS)."); | ||
| 467 | constant DebugFlag TOTAL_TEARING_DUMP = DEBUG_FLAG(145, "totaltearingdump", false, | ||
| 468 | "Dumps total tearing information."); | ||
| 469 | constant DebugFlag TOTAL_TEARING_DUMPVERBOSE = DEBUG_FLAG(146, "totaltearingdumpV", false, | ||
| 470 | "Dumps verbose total tearing information."); | ||
| 471 | constant DebugFlag PARALLEL_CODEGEN = DEBUG_FLAG(147, "parallelCodegen", true, | ||
| 472 | "Enables code generation in parallel (disable this if compiling a model causes you to run out of RAM)."); | ||
| 473 | constant DebugFlag SERIALIZED_SIZE = DEBUG_FLAG(148, "reportSerializedSize", false, | ||
| 474 | "Reports serialized sizes of various data structures used in the compiler."); | ||
| 475 | constant DebugFlag BACKEND_KEEP_ENV_GRAPH = DEBUG_FLAG(149, "backendKeepEnv", true, | ||
| 476 | "When enabled, the environment is kept when entering the backend, which enables CevalFunction (function interpretation) to work. This module not essential for the backend to function in most cases, but can improve simulation performance by evaluating functions. The drawback to keeping the environment graph in memory is that it is huge (~80% of the total memory in use when returning the frontend DAE)."); | ||
| 477 | constant DebugFlag DUMPBACKENDINLINE = DEBUG_FLAG(150, "dumpBackendInline", false, | ||
| 478 | "Dumps debug output while inline function."); | ||
| 479 | constant DebugFlag DUMPBACKENDINLINE_VERBOSE = DEBUG_FLAG(151, "dumpBackendInlineVerbose", false, | ||
| 480 | "Dumps debug output while inline function."); | ||
| 481 | constant DebugFlag BLT_MATRIX_DUMP = DEBUG_FLAG(152, "bltmatrixdump", false, | ||
| 482 | "Dumps the blt matrix in html file. IE seems to be very good in displaying large matrices."); | ||
| 483 | constant DebugFlag LIST_REVERSE_WRONG_ORDER = DEBUG_FLAG(153, "listAppendWrongOrder", true, | ||
| 484 | "Print notifications about bad usage of listAppend."); | ||
| 485 | constant DebugFlag PARTITION_INITIALIZATION = DEBUG_FLAG(154, "partitionInitialization", true, | ||
| 486 | "This flag controls if partitioning is applied to the initialization system."); | ||
| 487 | constant DebugFlag EVAL_PARAM_DUMP = DEBUG_FLAG(155, "evalParameterDump", false, | ||
| 488 | "Dumps information for evaluating parameters."); | ||
| 489 | constant DebugFlag NF_UNITCHECK = DEBUG_FLAG(156, "frontEndUnitCheck", false, | ||
| 490 | "Checks the consistency of units in equation."); | ||
| 491 | constant DebugFlag DISABLE_COLORING = DEBUG_FLAG(157, "disableColoring", false, | ||
| 492 | "Disables coloring algorithm while spasity detection."); | ||
| 493 | constant DebugFlag MERGE_ALGORITHM_SECTIONS = DEBUG_FLAG(158, "mergeAlgSections", false, | ||
| 494 | "Disables coloring algorithm while sparsity detection."); | ||
| 495 | constant DebugFlag WARN_NO_NOMINAL = DEBUG_FLAG(159, "warnNoNominal", false, | ||
| 496 | "Prints the iteration variables in the initialization and simulation DAE, which do not have a nominal value."); | ||
| 497 | constant DebugFlag REDUCE_DAE = DEBUG_FLAG(160, "backendReduceDAE", false, | ||
| 498 | "Prints all Reduce DAE debug information."); | ||
| 499 | constant DebugFlag IGNORE_CYCLES = DEBUG_FLAG(161, "ignoreCycles", false, | ||
| 500 | "Ignores cycles between constant/parameter components."); | ||
| 501 | constant DebugFlag ALIAS_CONFLICTS = DEBUG_FLAG(162, "aliasConflicts", false, | ||
| 502 | "Dumps alias sets with different start or nominal values."); | ||
| 503 | constant DebugFlag SUSAN_MATCHCONTINUE_DEBUG = DEBUG_FLAG(163, "susanDebug", false, | ||
| 504 | "Makes Susan generate code using try/else to better debug which function broke the expected match semantics."); | ||
| 505 | constant DebugFlag OLD_FE_UNITCHECK = DEBUG_FLAG(164, "oldFrontEndUnitCheck", false, | ||
| 506 | "Checks the consistency of units in equation (for the old front-end)."); | ||
| 507 | constant DebugFlag EXEC_STAT_EXTRA_GC = DEBUG_FLAG(165, "execstatGCcollect", false, | ||
| 508 | "When running execstat, also perform an extra full garbage collection."); | ||
| 509 | constant DebugFlag DEBUG_DAEMODE = DEBUG_FLAG(166, "debugDAEmode", false, | ||
| 510 | "Dump debug output for the DAEmode."); | ||
| 511 | constant DebugFlag NF_SCALARIZE = DEBUG_FLAG(167, "nfScalarize", true, | ||
| 512 | "Run scalarization in NF, default true."); | ||
| 513 | constant DebugFlag NF_EVAL_CONST_ARG_FUNCS = DEBUG_FLAG(168, "nfEvalConstArgFuncs", true, | ||
| 514 | "Evaluate all functions with constant arguments in the new frontend."); | ||
| 515 | constant DebugFlag NF_EXPAND_OPERATIONS = DEBUG_FLAG(169, "nfExpandOperations", true, | ||
| 516 | "Expand all unary/binary operations to scalar expressions in the new frontend."); | ||
| 517 | constant DebugFlag NF_API = DEBUG_FLAG(170, "nfAPI", true, | ||
| 518 | "Enables experimental new instantiation use in the OMC API."); | ||
| 519 | constant DebugFlag NF_API_DYNAMIC_SELECT = DEBUG_FLAG(171, "nfAPIDynamicSelect", false, | ||
| 520 | "Show DynamicSelect(static, dynamic) in annotations. Default to false and will select the first (static) expression"); | ||
| 521 | constant DebugFlag NF_API_NOISE = DEBUG_FLAG(172, "nfAPINoise", false, | ||
| 522 | "Enables error display for the experimental new instantiation use in the OMC API."); | ||
| 523 | constant DebugFlag FMI20_DEPENDENCIES = DEBUG_FLAG(173, "disableFMIDependency", false, | ||
| 524 | "Disables the dependency analysis and generation for FMI 2.0."); | ||
| 525 | constant DebugFlag WARNING_MINMAX_ATTRIBUTES = DEBUG_FLAG(174, "warnMinMax", true, | ||
| 526 | "Makes a warning assert from min/max variable attributes instead of error."); | ||
| 527 | constant DebugFlag NF_EXPAND_FUNC_ARGS = DEBUG_FLAG(175, "nfExpandFuncArgs", false, | ||
| 528 | "Expand all function arguments in the new frontend."); | ||
| 529 | constant DebugFlag DUMP_JL = DEBUG_FLAG(176, "dumpJL", false, | ||
| 530 | "Dumps the absyn representation of a program as a Julia representation"); | ||
| 531 | constant DebugFlag DUMP_ASSC = DEBUG_FLAG(177, "dumpASSC", false, | ||
| 532 | "Dumps the conversion process of analytical to structural singularities."); | ||
| 533 | constant DebugFlag SPLIT_CONSTANT_PARTS_SYMJAC = DEBUG_FLAG(178, "symJacConstantSplit", false, | ||
| 534 | "Generates all symbolic Jacobians with splitted constant parts."); | ||
| 535 | constant DebugFlag DUMP_FORCE_FMI_ATTRIBUTES = DEBUG_FLAG(179, "force-fmi-attributes", false, | ||
| 536 | "Force to export all fmi attributes to the modelDescription.xml, including those which have default values"); | ||
| 537 | constant DebugFlag DUMP_DATARECONCILIATION = DEBUG_FLAG(180, "dataReconciliation", false, | ||
| 538 | "Dumps all the dataReconciliation extraction algorithm procedure"); | ||
| 539 | constant DebugFlag ARRAY_CONNECT = DEBUG_FLAG(181, "arrayConnect", false, | ||
| 540 | "Use experimental array connection handler."); | ||
| 541 | constant DebugFlag COMBINE_SUBSCRIPTS = DEBUG_FLAG(182, "combineSubscripts", false, | ||
| 542 | "Move all subscripts to the end of component references."); | ||
| 543 | constant DebugFlag ZMQ_LISTEN_TO_ALL = DEBUG_FLAG(183, "zmqDangerousAcceptConnectionsFromAnywhere", false, | ||
| 544 | "When opening a zmq connection, listen on all interfaces instead of only connections from 127.0.0.1."); | ||
| 545 | constant DebugFlag DUMP_CONVERSION_RULES = DEBUG_FLAG(184, "dumpConversionRules", false, | ||
| 546 | "Dumps the rules when converting a package using a conversion script."); | ||
| 547 | constant DebugFlag PRINT_RECORD_TYPES = DEBUG_FLAG(185, "printRecordTypes", false, | ||
| 548 | "Prints out record types as part of the flat code."); | ||
| 549 | constant DebugFlag DUMP_SIMPLIFY = DEBUG_FLAG(186, "dumpSimplify", false, | ||
| 550 | "Dumps expressions before and after simplification."); | ||
| 551 | constant DebugFlag DUMP_BACKEND_CLOCKS = DEBUG_FLAG(187, "dumpBackendClocks", false, | ||
| 552 | "Dumps times for each backend module (only new backend)."); | ||
| 553 | constant DebugFlag DUMP_SET_BASED_GRAPHS = DEBUG_FLAG(188, "dumpSetBasedGraphs", false, | ||
| 554 | "Dumps information about set based graphs for efficient array handling (only new frontend and new backend)."); | ||
| 555 | constant DebugFlag MERGE_COMPONENTS = DEBUG_FLAG(189, "mergeComponents", false, | ||
| 556 | "Enables automatic merging of components into arrays."); | ||
| 557 | constant DebugFlag DUMP_SLICE = DEBUG_FLAG(190, "dumpSlice", false, | ||
| 558 | "Dumps information about the slicing process (pseudo-array causalization)."); | ||
| 559 | constant DebugFlag VECTORIZE_BINDINGS = DEBUG_FLAG(191, "vectorizeBindings", false, | ||
| 560 | "Turns on vectorization of bindings when scalarization is turned off."); | ||
| 561 | constant DebugFlag DUMP_EVENTS = DEBUG_FLAG(192, "dumpEvents", false, | ||
| 562 | "Dumps information about the detected event functions."); | ||
| 563 | constant DebugFlag DUMP_RESIZABLE = DEBUG_FLAG(193, "dumpResizable", false, | ||
| 564 | "Dumps information about resizable paremeter handling."); | ||
| 565 | constant DebugFlag DUMP_SOLVE = DEBUG_FLAG(194, "dumpSolve", false, | ||
| 566 | "Dumps information about equation solving."); | ||
| 567 | constant DebugFlag FORCE_SCALARIZE = DEBUG_FLAG(195, "forceScalarize", false, | ||
| 568 | "Forces scalarization to be done when it would normally be automatically disabled."); | ||
| 569 | constant DebugFlag DEBUG_ADJOINT = DEBUG_FLAG(196, "debugAdjoint", false, | ||
| 570 | "Dumps debug output for the adjoint differentiation process in the new backend."); | ||
| 571 | constant DebugFlag FLOW_ALIAS_ELIMINATION = DEBUG_FLAG(197, "flowAliasElimination", false, | ||
| 572 | "Enables simple alias elimination of flow variables in stream connectors."); | ||
| 573 | constant DebugFlag DUMP_CHECK_MODEL = DEBUG_FLAG(198, "dumpCheckModel", false, | ||
| 574 | "Dumps the variables and equations found by checkModel."); | ||
| 575 | constant DebugFlag CHECK_DEF_USE = DEBUG_FLAG(199, "checkDefUse", false, | ||
| 576 | "Warns about variables in functions that cannot statically be proven to be defined (given a value) before they are used, e.g. variables only assigned on some control flow paths. Per the Modelica specification using an uninitialized variable is an error."); | ||
| 577 | constant DebugFlag TEARING_COST = DEBUG_FLAG(200, "tearingCost", false, | ||
| 578 | "Dumps the estimated cost of every torn system against solving it untorn."); | ||
| 579 | constant DebugFlag OMEDIT = DEBUG_FLAG(201, "omedit", false, | ||
| 580 | "Set by OMEdit, so the compiler can emit output only a GUI consumes."); | ||
| 581 | |||
| 582 | public | ||
| 583 | // CONFIGURATION FLAGS | ||
| 584 | constant ConfigFlag DEBUG = CONFIG_FLAG(1, "debug", | ||
| 585 | SOME("d"), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 586 | "Sets debug flags. Use --help=debug to see available flags."); | ||
| 587 | constant ConfigFlag HELP = CONFIG_FLAG(2, "help", | ||
| 588 | SOME("h"), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 589 | "Displays the help text. Use --help=topics for more information."); | ||
| 590 | constant ConfigFlag RUNNING_TESTSUITE = CONFIG_FLAG(3, "running-testsuite", | ||
| 591 | NONE(), INTERNAL(), STRING_FLAG(""), NONE(), | ||
| 592 | "Used when running the testsuite."); | ||
| 593 | constant ConfigFlag SHOW_VERSION = CONFIG_FLAG(4, "version", | ||
| 594 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 595 | "Print the version and exit."); | ||
| 596 | constant ConfigFlag TARGET = CONFIG_FLAG(5, "target", NONE(), EXTERNAL(), | ||
| 597 | STRING_FLAG("gcc"), SOME(STRING_OPTION({"gcc", "msvc","msvc10","msvc12","msvc13","msvc15","msvc19", "vxworks69", "debugrt"})), | ||
| 598 | "Sets the target compiler to use."); | ||
| 599 | constant ConfigFlag GRAMMAR = CONFIG_FLAG(6, "grammar", SOME("g"), EXTERNAL(), | ||
| 600 | ENUM_FLAG(MODELICA, {("Modelica", MODELICA), ("MetaModelica", METAMODELICA), ("ParModelica", PARMODELICA), ("Optimica", OPTIMICA), ("PDEModelica", PDEMODELICA)}), | ||
| 601 | NONE(), | ||
| 602 | "Sets the grammar and semantics to accept."); | ||
| 603 | constant ConfigFlag ANNOTATION_VERSION = CONFIG_FLAG(7, "annotationVersion", | ||
| 604 | NONE(), EXTERNAL(), STRING_FLAG("3.x"), SOME(STRING_OPTION({"1.x", "2.x", "3.x"})), | ||
| 605 | "Sets the annotation version that should be used."); | ||
| 606 | constant ConfigFlag LANGUAGE_STANDARD = CONFIG_FLAG(8, "std", NONE(), EXTERNAL(), | ||
| 607 | ENUM_FLAG(1000, | ||
| 608 | {("1.x", 10), ("2.x", 20), ("3.0", 30), ("3.1", 31), ("3.2", 32), ("3.3", 33), | ||
| 609 | ("3.4", 34), ("3.5", 35), ("3.6", 36), ("3.7", 37), ("latest",1000), ("experimental", 9999)}), | ||
| 610 | NONE(), | ||
| 611 | "Sets the language standard that should be used."); | ||
| 612 | constant ConfigFlag SHOW_ERROR_MESSAGES = CONFIG_FLAG(9, "showErrorMessages", | ||
| 613 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 614 | "Show error messages immediately when they happen."); | ||
| 615 | constant ConfigFlag SHOW_ANNOTATIONS = CONFIG_FLAG(10, "showAnnotations", | ||
| 616 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 617 | "Show annotations in the flattened code."); | ||
| 618 | constant ConfigFlag NO_SIMPLIFY = CONFIG_FLAG(11, "noSimplify", | ||
| 619 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 620 | "Do not simplify expressions if set."); | ||
| 621 | |||
| 622 | constant String removeSimpleEquationDesc = "Performs alias elimination and removes constant variables from the DAE, replacing all occurrences of the old variable reference with the new value (constants) or variable reference (alias elimination)."; | ||
| 623 | |||
| 624 | constant ConfigFlag PRE_OPT_MODULES = CONFIG_FLAG(12, "preOptModules", | ||
| 625 | NONE(), EXTERNAL(), STRING_LIST_FLAG({ | ||
| 626 | "normalInlineFunction", | ||
| 627 | "evaluateParameters", | ||
| 628 | "simplifyIfEquations", | ||
| 629 | "expandDerOperator", | ||
| 630 | "clockPartitioning", | ||
| 631 | "findStateOrder", | ||
| 632 | "replaceEdgeChange", | ||
| 633 | "inlineArrayEqn", | ||
| 634 | "removeEqualRHS", | ||
| 635 | "removeSimpleEquations", | ||
| 636 | "comSubExp", | ||
| 637 | "resolveLoops", | ||
| 638 | "evalFunc", | ||
| 639 | "encapsulateWhenConditions" | ||
| 640 | }), | ||
| 641 | SOME(STRING_DESC_OPTION({ | ||
| 642 | ("introduceOutputAliases", "Introduces aliases for top-level outputs."), | ||
| 643 | ("clockPartitioning", "Does the clock partitioning."), | ||
| 644 | ("collapseArrayExpressions", collapseArrayExpressionsText), | ||
| 645 | ("comSubExp", "Introduces alias assignments for variables which are assigned to simple terms i.e. a = b/c; d = b/c; --> a=d"), | ||
| 646 | ("dumpDAE", "dumps the DAE representation of the current transformation state"), | ||
| 647 | ("dumpDAEXML", "dumps the DAE as xml representation of the current transformation state"), | ||
| 648 | ("encapsulateWhenConditions", "This module replaces each when condition with a boolean variable."), | ||
| 649 | ("evalFunc", "evaluates functions partially"), | ||
| 650 | ("evaluateParameters", "Evaluates parameters with annotation(Evaluate=true). Use '--evaluateFinalParameters=true' or '--evaluateProtectedParameters=true' to specify additional parameters to be evaluated. Use '--replaceEvaluatedParameters=true' if the evaluated parameters should be replaced in the DAE. To evaluate all parameters in the Frontend use -d=evaluateAllParameters."), | ||
| 651 | ("expandDerOperator", "Expands der(expr) using Derive.differentiteExpTime."), | ||
| 652 | ("findStateOrder", "Sets derivative information to states."), | ||
| 653 | ("inlineArrayEqn", "This module expands all array equations to scalar equations."), | ||
| 654 | ("normalInlineFunction", "Perform function inlining for function with annotation Inline=true."), | ||
| 655 | ("inputDerivativesForDynOpt", "Allowed derivatives of inputs in dyn. optimization."), | ||
| 656 | ("introduceDerAlias", "Adds for every der-call an alias equation e.g. dx = der(x)."), | ||
| 657 | ("removeEqualRHS", "Detects equal expressions of the form a=<exp> and b=<exp> and substitutes them to get speed up."), | ||
| 658 | ("removeProtectedParameters", "Replace all parameters with protected=true in the system."), | ||
| 659 | ("removeSimpleEquations", removeSimpleEquationDesc), | ||
| 660 | ("removeUnusedParameter", "Strips all parameter not present in the equations from the system."), | ||
| 661 | ("removeUnusedVariables", "Strips all variables not present in the equations from the system."), | ||
| 662 | ("removeVerySimpleEquations", "[Experimental] Like removeSimpleEquations, but less thorough. Note that this always uses the experimental new alias elimination, --removeSimpleEquations=new, which makes it unstable. In particular, MultiBody systems fail to translate correctly. It can be used for simple (but large) systems of equations."), | ||
| 663 | ("replaceEdgeChange", "Replace edge(b) = b and not pre(b) and change(b) = v <> pre(v)."), | ||
| 664 | ("residualForm", "Transforms simple equations x=y to zero-sum equations 0=y-x."), | ||
| 665 | ("resolveLoops", "resolves linear equations in loops"), | ||
| 666 | ("simplifyAllExpressions", "Does simplifications on all expressions."), | ||
| 667 | ("simplifyIfEquations", "Tries to simplify if equations by use of information from evaluated parameters."), | ||
| 668 | ("sortEqnsVars", "Heuristic sorting for equations and variables."), | ||
| 669 | ("unitChecking", "This module is no longer available and its use is deprecated. Use --unitChecking instead."), | ||
| 670 | ("wrapFunctionCalls", "This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.") | ||
| 671 | })), | ||
| 672 | "Sets the pre optimization modules to use in the back end. See --help=optmodules for more info."); | ||
| 673 | constant ConfigFlag CHEAPMATCHING_ALGORITHM = CONFIG_FLAG(13, "cheapmatchingAlgorithm", | ||
| 674 | NONE(), EXTERNAL(), INT_FLAG(3), | ||
| 675 | SOME(STRING_DESC_OPTION({ | ||
| 676 | ("0", "No cheap matching."), | ||
| 677 | ("1", "Cheap matching, traverses all equations and match the first free variable."), | ||
| 678 | ("3", "Random Karp-Sipser: R. M. Karp and M. Sipser. Maximum matching in sparse random graphs.")})), | ||
| 679 | "Sets the cheap matching algorithm to use. A cheap matching algorithm gives a jump start matching by heuristics."); | ||
| 680 | constant ConfigFlag MATCHING_ALGORITHM = CONFIG_FLAG(14, "matchingAlgorithm", | ||
| 681 | NONE(), EXTERNAL(), STRING_FLAG("PFPlusExt"), | ||
| 682 | SOME(STRING_DESC_OPTION({ | ||
| 683 | ("BFSB", "Breadth First Search based algorithm."), | ||
| 684 | ("DFSB", "Depth First Search based algorithm."), | ||
| 685 | ("MC21A", "Depth First Search based algorithm with look ahead feature."), | ||
| 686 | ("PF", "Depth First Search based algorithm with look ahead feature."), | ||
| 687 | ("PFPlus", "Depth First Search based algorithm with look ahead feature and fair row traversal."), | ||
| 688 | ("HK", "Combined BFS and DFS algorithm."), | ||
| 689 | ("HKDW", "Combined BFS and DFS algorithm."), | ||
| 690 | ("ABMP", "Combined BFS and DFS algorithm."), | ||
| 691 | ("PR", "Matching algorithm using push relabel mechanism."), | ||
| 692 | ("DFSBExt", "Depth First Search based Algorithm external c implementation."), | ||
| 693 | ("BFSBExt", "Breadth First Search based Algorithm external c implementation."), | ||
| 694 | ("MC21AExt", "Depth First Search based Algorithm with look ahead feature external c implementation."), | ||
| 695 | ("PFExt", "Depth First Search based Algorithm with look ahead feature external c implementation."), | ||
| 696 | ("PFPlusExt", "Depth First Search based Algorithm with look ahead feature and fair row traversal external c implementation."), | ||
| 697 | ("HKExt", "Combined BFS and DFS algorithm external c implementation."), | ||
| 698 | ("HKDWExt", "Combined BFS and DFS algorithm external c implementation."), | ||
| 699 | ("ABMPExt", "Combined BFS and DFS algorithm external c implementation."), | ||
| 700 | ("PRExt", "Matching algorithm using push relabel mechanism external c implementation."), | ||
| 701 | ("BB", "BBs try."), | ||
| 702 | ("SBGraph", "Set-Based Graph matching algorithm for efficient array handling."), | ||
| 703 | ("pseudo", "Pseudo array matching that uses scalar matching and reconstructs arrays afterwards as much as possible.")})), | ||
| 704 | "Sets the matching algorithm to use. See --help=optmodules for more info."); | ||
| 705 | constant ConfigFlag INDEX_REDUCTION_METHOD = CONFIG_FLAG(15, "indexReductionMethod", | ||
| 706 | NONE(), EXTERNAL(), STRING_FLAG("dynamicStateSelection"), | ||
| 707 | SOME(STRING_DESC_OPTION({ | ||
| 708 | ("none", "Skip index reduction"), | ||
| 709 | ("uode", "Use the underlying ODE without the constraints."), | ||
| 710 | ("dynamicStateSelection", "Simple index reduction method, select (dynamic) dummy states based on analysis of the system."), | ||
| 711 | ("dummyDerivatives", "Simple index reduction method, select (static) dummy states based on heuristic.") | ||
| 712 | })), | ||
| 713 | "Sets the index reduction method to use. See --help=optmodules for more info."); | ||
| 714 | constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules", | ||
| 715 | NONE(), EXTERNAL(), STRING_LIST_FLAG({ | ||
| 716 | "lateInlineFunction", | ||
| 717 | "wrapFunctionCalls", | ||
| 718 | "inlineArrayEqn", | ||
| 719 | "constantLinearSystem", | ||
| 720 | "simplifysemiLinear", | ||
| 721 | "removeSimpleEquations", | ||
| 722 | "simplifyComplexFunction", | ||
| 723 | "solveSimpleEquations", | ||
| 724 | "tearingSystem", | ||
| 725 | "inputDerivativesUsed", | ||
| 726 | "calculateStrongComponentJacobians", | ||
| 727 | "calculateStateSetsJacobians", | ||
| 728 | "symbolicJacobian", | ||
| 729 | "removeConstants", | ||
| 730 | "simplifyTimeIndepFuncCalls", | ||
| 731 | "simplifyAllExpressions", | ||
| 732 | "findZeroCrossings", | ||
| 733 | "collapseArrayExpressions" | ||
| 734 | }), | ||
| 735 | SOME(STRING_DESC_OPTION({ | ||
| 736 | ("addScaledVars_states", "added var_norm = var/nominal, where var is state"), | ||
| 737 | ("addScaledVars_inputs", "added var_norm = var/nominal, where var is input"), | ||
| 738 | ("addTimeAsState", "Experimental feature: this replaces each occurrence of variable time with a new introduced state $time with equation der($time) = 1.0"), | ||
| 739 | ("calculateStateSetsJacobians", "Generates analytical jacobian for dynamic state selection sets."), | ||
| 740 | ("calculateStrongComponentJacobians", "Generates analytical jacobian for torn linear and non-linear strong components. By default linear components and non-linear components with user-defined function calls are skipped. See also debug flags: LSanalyticJacobian, NLSanalyticJacobian and forceNLSanalyticJacobian"), | ||
| 741 | ("collapseArrayExpressions", collapseArrayExpressionsText), | ||
| 742 | ("constantLinearSystem", "Evaluates constant linear systems (a*x+b*y=c; d*x+e*y=f; a,b,c,d,e,f are constants) at compile-time."), | ||
| 743 | ("countOperations", "Count the mathematical operations of the system."), | ||
| 744 | ("cseBinary", "Common Sub-expression Elimination"), | ||
| 745 | ("dumpComponentsGraphStr", "Dumps the assignment graph used to determine strong components to format suitable for Mathematica"), | ||
| 746 | ("dumpDAE", "dumps the DAE representation of the current transformation state"), | ||
| 747 | ("dumpDAEXML", "dumps the DAE as xml representation of the current transformation state"), | ||
| 748 | ("evaluateParameters", "Evaluates parameters with annotation(Evaluate=true). Use '--evaluateFinalParameters=true' or '--evaluateProtectedParameters=true' to specify additional parameters to be evaluated. Use '--replaceEvaluatedParameters=true' if the evaluated parameters should be replaced in the DAE. To evaluate all parameters in the Frontend use -d=evaluateAllParameters."), | ||
| 749 | ("extendDynamicOptimization", "Move loops to constraints."), | ||
| 750 | ("generateSymbolicLinearization", "Generates symbolic linearization matrices A,B,C,D for linear model:\n\t:math:`\\dot{x} = Ax + Bu`\n\t:math:`y = Cx + Du`"), | ||
| 751 | ("generateSymbolicSensitivities", "Generates symbolic Sensivities matrix, where der(x) is differentiated w.r.t. param."), | ||
| 752 | ("inlineArrayEqn", "This module expands all array equations to scalar equations."), | ||
| 753 | ("inputDerivativesUsed", "Checks if derivatives of inputs are need to calculate the model."), | ||
| 754 | ("lateInlineFunction", "Perform function inlining for function with annotation LateInline=true."), | ||
| 755 | ("partlintornsystem","partitions linear torn systems."), | ||
| 756 | ("recursiveTearing", "inline and repeat tearing"), | ||
| 757 | ("reduceDynamicOptimization", "Removes equations which are not needed for the calculations of cost and constraints. This module requires --postOptModules+=reduceDynamicOptimization."), | ||
| 758 | ("relaxSystem", "relaxation from gausian elemination"), | ||
| 759 | ("removeConstants", "Remove all constants in the system."), | ||
| 760 | ("removeEqualRHS", "Detects equal function calls of the form a=f(b) and c=f(b) and substitutes them to get speed up."), | ||
| 761 | ("removeSimpleEquations", removeSimpleEquationDesc), | ||
| 762 | ("removeUnusedParameter", "Strips all parameter not present in the equations from the system to get speed up for compilation of target code."), | ||
| 763 | ("removeUnusedVariables", "Strips all variables not present in the equations from the system to get speed up for compilation of target code."), | ||
| 764 | ("reshufflePost", "Reshuffles algebraic loops."), | ||
| 765 | ("simplifyAllExpressions", "Does simplifications on all expressions."), | ||
| 766 | ("simplifyComplexFunction", "Some simplifications on complex functions (complex refers to the internal data structure)"), | ||
| 767 | ("simplifyConstraints", "Rewrites nonlinear constraints into box constraints if possible. This module requires +gDynOpt."), | ||
| 768 | ("simplifyLoops", "Simplifies algebraic loops. This modules requires +simplifyLoops."), | ||
| 769 | ("simplifyTimeIndepFuncCalls", "Simplifies time independent built in function calls like pre(param) -> param, der(param) -> 0.0, change(param) -> false, edge(param) -> false."), | ||
| 770 | ("simplifysemiLinear", "Simplifies calls to semiLinear."), | ||
| 771 | ("solveLinearSystem", "solve linear system with newton step"), | ||
| 772 | ("solveSimpleEquations", "Solves simple equations"), | ||
| 773 | ("symSolver", "Rewrites the ode system for implicit Euler method. This module requires +symSolver."), | ||
| 774 | ("symbolicJacobian", "Detects the sparse pattern of the ODE system and calculates also the symbolic Jacobian if flag '--generateDynamicJacobian=symbolic'."), | ||
| 775 | ("tearingSystem", "For method selection use flag tearingMethod."), | ||
| 776 | ("wrapFunctionCalls", "This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.") | ||
| 777 | })), | ||
| 778 | "Sets the post optimization modules to use in the back end. See --help=optmodules for more info."); | ||
| 779 | constant ConfigFlag SIMCODE_TARGET = CONFIG_FLAG(17, "simCodeTarget", | ||
| 780 | NONE(), EXTERNAL(), STRING_FLAG("C"), | ||
| 781 | SOME(STRING_OPTION({"None", "C", "C.old", "Cpp", "ExperimentalEmbeddedC", "ESP32", "JavaScript", "XML", "MidC", "wasm-jit", "wasm"})), | ||
| 782 | "Sets the target language for the code generation."); | ||
| 783 | constant ConfigFlag ORDER_CONNECTIONS = CONFIG_FLAG(18, "orderConnections", | ||
| 784 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 785 | "Orders connect equations alphabetically if set."); | ||
| 786 | constant ConfigFlag TYPE_INFO = CONFIG_FLAG(19, "typeinfo", | ||
| 787 | SOME("t"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 788 | "Prints out extra type information if set."); | ||
| 789 | constant ConfigFlag KEEP_ARRAYS = CONFIG_FLAG(20, "keepArrays", | ||
| 790 | SOME("a"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 791 | "Sets whether to split arrays or not."); | ||
| 792 | constant ConfigFlag MODELICA_OUTPUT = CONFIG_FLAG(21, "modelicaOutput", | ||
| 793 | SOME("m"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 794 | "Enables valid modelica output for flat modelica."); | ||
| 795 | constant ConfigFlag SILENT = CONFIG_FLAG(22, "silent", | ||
| 796 | SOME("q"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 797 | "Turns on silent mode."); | ||
| 798 | constant ConfigFlag NUM_PROC = CONFIG_FLAG(23, "numProcs", | ||
| 799 | SOME("n"), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 800 | "Sets the number of processors to use (0=default=auto)."); | ||
| 801 | constant ConfigFlag INST_CLASS = CONFIG_FLAG(24, "instClass", | ||
| 802 | SOME("i"), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 803 | "Instantiate the class given by the fully qualified path."); | ||
| 804 | constant ConfigFlag VECTORIZATION_LIMIT = CONFIG_FLAG(25, "vectorizationLimit", | ||
| 805 | SOME("v"), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 806 | "Sets the vectorization limit, arrays and matrices larger than this will not be vectorized."); | ||
| 807 | constant ConfigFlag SIMULATION_CG = CONFIG_FLAG(26, "simulationCg", | ||
| 808 | SOME("s"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 809 | "Turns on simulation code generation."); | ||
| 810 | constant ConfigFlag EVAL_PARAMS_IN_ANNOTATIONS = CONFIG_FLAG(27, | ||
| 811 | "evalAnnotationParams", NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 812 | "Sets whether to evaluate parameters in annotations or not."); | ||
| 813 | constant ConfigFlag CHECK_MODEL = CONFIG_FLAG(28, | ||
| 814 | "checkModel", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 815 | "Set when checkModel is used to turn on specific features for checking."); | ||
| 816 | constant ConfigFlag CEVAL_EQUATION = CONFIG_FLAG(29, | ||
| 817 | "cevalEquation", NONE(), INTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 818 | ""); | ||
| 819 | constant ConfigFlag UNIT_CHECKING = CONFIG_FLAG(30, | ||
| 820 | "unitChecking", NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 821 | "Enable unit checking."); | ||
| 822 | constant ConfigFlag GENERATE_LABELED_SIMCODE = CONFIG_FLAG(31, | ||
| 823 | "generateLabeledSimCode", NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 824 | "Turns on labeled SimCode generation for reduction algorithms."); | ||
| 825 | constant ConfigFlag REDUCE_TERMS = CONFIG_FLAG(32, | ||
| 826 | "reduceTerms", NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 827 | "Turns on reducing terms for reduction algorithms."); | ||
| 828 | constant ConfigFlag REDUCTION_METHOD = CONFIG_FLAG(33, "reductionMethod", | ||
| 829 | NONE(), EXTERNAL(), STRING_FLAG("deletion"), | ||
| 830 | SOME(STRING_OPTION({"deletion","substitution","linearization"})), | ||
| 831 | "Sets the reduction method to be used."); | ||
| 832 | constant ConfigFlag DEMO_MODE = CONFIG_FLAG(34, "demoMode", | ||
| 833 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 834 | "Disable Warning/Error Massages."); | ||
| 835 | constant ConfigFlag LOCALE_FLAG = CONFIG_FLAG(35, "locale", | ||
| 836 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 837 | "Override the locale from the environment."); | ||
| 838 | constant ConfigFlag DEFAULT_OPENCL_DEVICE = CONFIG_FLAG(36, "defaultOCLDevice", | ||
| 839 | SOME("o"), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 840 | "Sets the default OpenCL device to be used for parallel execution. 0 (the\n default) picks a suitable device automatically."); | ||
| 841 | constant ConfigFlag MAXTRAVERSALS = CONFIG_FLAG(37, "maxTraversals", | ||
| 842 | NONE(), EXTERNAL(), INT_FLAG(2),NONE(), | ||
| 843 | "Maximal traversals to find simple equations in the acausal system."); | ||
| 844 | constant ConfigFlag DUMP_TARGET = CONFIG_FLAG(38, "dumpTarget", | ||
| 845 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 846 | "Redirect the dump to file. If the file ends with .html HTML code is generated."); | ||
| 847 | constant ConfigFlag DELAY_BREAK_LOOP = CONFIG_FLAG(39, "delayBreakLoop", | ||
| 848 | NONE(), EXTERNAL(), BOOL_FLAG(true),NONE(), | ||
| 849 | "Enables (very) experimental code to break algebraic loops using the delay() operator. Probably messes with initialization."); | ||
| 850 | constant ConfigFlag TEARING_METHOD = CONFIG_FLAG(40, "tearingMethod", | ||
| 851 | NONE(), EXTERNAL(), STRING_FLAG("cellier"), | ||
| 852 | SOME(STRING_DESC_OPTION({ | ||
| 853 | ("noTearing", "Deprecated, use minimalTearing."), | ||
| 854 | ("minimalTearing", "Minimal tearing method to only tear discrete variables."), | ||
| 855 | ("omcTearing", "Tearing method developed by TU Dresden: Frenkel, Schubert."), | ||
| 856 | ("cellier", "Tearing based on Celliers method, revised by FH Bielefeld: Täuber, Patrick"), | ||
| 857 | ("guruTearing", "Tearing based solely on TearingSelect annotation. Forces prefer/always variables to be iteration variables.")})), | ||
| 858 | "Sets the tearing method to use. Select no tearing or choose tearing method."); | ||
| 859 | constant ConfigFlag TEARING_HEURISTIC = CONFIG_FLAG(41, "tearingHeuristic", | ||
| 860 | NONE(), EXTERNAL(), STRING_FLAG("MC3"), | ||
| 861 | SOME(STRING_DESC_OPTION({ | ||
| 862 | ("MC1", "Original cellier with consideration of impossible assignments and discrete Vars."), | ||
| 863 | ("MC2", "Modified cellier, drop first step."), | ||
| 864 | ("MC11", "Modified MC1, new last step 'count impossible assignments'."), | ||
| 865 | ("MC21", "Modified MC2, new last step 'count impossible assignments'."), | ||
| 866 | ("MC12", "Modified MC1, step 'count impossible assignments' before last step."), | ||
| 867 | ("MC22", "Modified MC2, step 'count impossible assignments' before last step."), | ||
| 868 | ("MC13", "Modified MC1, build sum of impossible assignment and causalizable equations, choose var with biggest sum."), | ||
| 869 | ("MC23", "Modified MC2, build sum of impossible assignment and causalizable equations, choose var with biggest sum."), | ||
| 870 | ("MC231", "Modified MC23, Two rounds, choose better potentials-set."), | ||
| 871 | ("MC3", "Modified cellier, build sum of impossible assignment and causalizable equations for all vars, choose var with biggest sum."), | ||
| 872 | ("MC4", "Modified cellier, use all heuristics, choose var that occurs most in potential sets")})), | ||
| 873 | "Sets the tearing heuristic to use for Cellier-tearing."); | ||
| 874 | constant ConfigFlag SCALARIZE_MINMAX = CONFIG_FLAG(42, "scalarizeMinMax", | ||
| 875 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 876 | "Scalarizes the builtin min/max reduction operators if true."); | ||
| 877 | constant ConfigFlag STRICT = CONFIG_FLAG(43, "strict", | ||
| 878 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 879 | "Enables stricter enforcement of Modelica language rules."); | ||
| 880 | constant ConfigFlag SCALARIZE_BINDINGS = CONFIG_FLAG(44, "scalarizeBindings", | ||
| 881 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 882 | "Always scalarizes bindings if set."); | ||
| 883 | constant ConfigFlag HPCOM_SCHEDULER = CONFIG_FLAG(45, "hpcomScheduler", | ||
| 884 | NONE(), EXTERNAL(), STRING_FLAG("level"), NONE(), | ||
| 885 | "Sets the scheduler for task graph scheduling (list | listr | level | levelfix | ext | metis | mcp | taskdep | tds | bls | rand | none). Default: level."); | ||
| 886 | constant ConfigFlag HPCOM_CODE = CONFIG_FLAG(46, "hpcomCode", | ||
| 887 | NONE(), EXTERNAL(), STRING_FLAG("openmp"), NONE(), | ||
| 888 | "Sets the code-type produced by hpcom (openmp | pthreads | pthreads_spin | tbb | mpi). Default: openmp."); | ||
| 889 | constant ConfigFlag REWRITE_RULES_FILE = CONFIG_FLAG(47, "rewriteRulesFile", NONE(), EXTERNAL(), | ||
| 890 | STRING_FLAG(""), NONE(), | ||
| 891 | "Activates user given rewrite rules for Absyn expressions. The rules are read from the given file and are of the form rewrite(fromExp, toExp);"); | ||
| 892 | constant ConfigFlag REPLACE_HOMOTOPY = CONFIG_FLAG(48, "replaceHomotopy", | ||
| 893 | NONE(), EXTERNAL(), STRING_FLAG("none"), | ||
| 894 | SOME(STRING_DESC_OPTION({ | ||
| 895 | ("none", "Default, do not replace homotopy."), | ||
| 896 | ("actual", "Replace homotopy(actual, simplified) with actual."), | ||
| 897 | ("simplified", "Replace homotopy(actual, simplified) with simplified.") | ||
| 898 | })), | ||
| 899 | "Replaces homotopy(actual, simplified) with the actual expression or the simplified expression. Good for debugging models which use homotopy. The default is to not replace homotopy."); | ||
| 900 | constant ConfigFlag GENERATE_DYNAMIC_JACOBIAN = CONFIG_FLAG(49, "generateDynamicJacobian", | ||
| 901 | NONE(), EXTERNAL(), STRING_FLAG("numeric"), | ||
| 902 | SOME(STRING_DESC_OPTION({ | ||
| 903 | ("none", ("Does not generate Jacobian. For use with explicit solvers.")), | ||
| 904 | ("numeric", ("Generates sparsity pattern for numeric Jacobian.")), | ||
| 905 | ("symbolic", ("Generates symbolic Jacobian. Used by dassl or ida solver with simulation flag '-jacobian'.")), | ||
| 906 | ("symbolicadjoint", ("Generates adjoint Jacobian symbolically.")), | ||
| 907 | ("bidirectional", ("Generates bidirectional Jacobian using star bicoloring (ColPack). Combines forward and adjoint modes.")) | ||
| 908 | })), | ||
| 909 | "Select how Jacobian matrix is generated, where der(x) is differentiated w.r.t. x."); | ||
| 910 | constant ConfigFlag GENERATE_SYMBOLIC_LINEARIZATION = CONFIG_FLAG(50, "generateSymbolicLinearization", | ||
| 911 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 912 | "Generates symbolic linearization matrices A,B,C,D for linear model:\n\t\t:math:`\\dot{x} = Ax + Bu`\n\t\t:math:`y = Cx + Du`"); | ||
| 913 | constant ConfigFlag INT_ENUM_CONVERSION = CONFIG_FLAG(51, "intEnumConversion", | ||
| 914 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 915 | "Allow Integer to enumeration conversion."); | ||
| 916 | constant ConfigFlag PROFILING_LEVEL = CONFIG_FLAG(52, "profiling", | ||
| 917 | NONE(), EXTERNAL(), STRING_FLAG("none"), SOME(STRING_DESC_OPTION({ | ||
| 918 | ("none","Generate code without profiling"), | ||
| 919 | ("blocks","Generate code for profiling function calls as well as linear and non-linear systems of equations"), | ||
| 920 | ("blocks+html","Like blocks, but also run xsltproc and gnuplot to generate an html report"), | ||
| 921 | ("all","Generate code for profiling of all functions and equations"), | ||
| 922 | ("all_perf","Generate code for profiling of all functions and equations with additional performance data using the papi-interface (cpp-runtime)"), | ||
| 923 | ("all_stat","Generate code for profiling of all functions and equations with additional statistics (cpp-runtime)") | ||
| 924 | })), | ||
| 925 | "Sets the profiling level to use. Profiled equations and functions record execution time and count for each time step taken by the integrator."); | ||
| 926 | constant ConfigFlag RESHUFFLE = CONFIG_FLAG(53, "reshuffle", | ||
| 927 | NONE(), EXTERNAL(), INT_FLAG(1), NONE(), | ||
| 928 | "sets tolerance of reshuffling algorithm: 1: conservative, 2: more tolerant, 3 resolve all"); | ||
| 929 | constant ConfigFlag GENERATE_DYN_OPTIMIZATION_PROBLEM = CONFIG_FLAG(54, "gDynOpt", | ||
| 930 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 931 | "Generate dynamic optimization problem based on annotation approach."); | ||
| 932 | constant ConfigFlag MAX_SIZE_FOR_SOLVE_LINIEAR_SYSTEM = CONFIG_FLAG(55, "maxSizeSolveLinearSystem", | ||
| 933 | NONE(), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 934 | "Max size for solveLinearSystem."); | ||
| 935 | constant ConfigFlag CPP_FLAGS = CONFIG_FLAG(56, "cppFlags", | ||
| 936 | NONE(), EXTERNAL(), STRING_LIST_FLAG({""}), NONE(), | ||
| 937 | "Sets extra flags for compilation with the C++ compiler (e.g. +cppFlags=-O3,-Wall)"); | ||
| 938 | constant ConfigFlag REMOVE_SIMPLE_EQUATIONS = CONFIG_FLAG(57, "removeSimpleEquations", | ||
| 939 | NONE(), EXTERNAL(), STRING_FLAG("default"), | ||
| 940 | SOME(STRING_DESC_OPTION({ | ||
| 941 | ("none", "Disables module"), | ||
| 942 | ("default", "Performs alias elimination and removes constant variables. Default case uses in preOpt phase the fastAcausal and in postOpt phase the causal implementation."), | ||
| 943 | ("causal", "Performs alias elimination and removes constant variables. Causal implementation."), | ||
| 944 | ("fastAcausal", "Performs alias elimination and removes constant variables. fastImplementation fastAcausal."), | ||
| 945 | ("allAcausal", "Performs alias elimination and removes constant variables. Implementation allAcausal."), | ||
| 946 | ("new", "New implementation (experimental)") | ||
| 947 | })), | ||
| 948 | "Specifies method that removes simple equations."); | ||
| 949 | constant ConfigFlag DYNAMIC_TEARING = CONFIG_FLAG(58, "dynamicTearing", | ||
| 950 | NONE(), EXTERNAL(), STRING_FLAG("false"), | ||
| 951 | SOME(STRING_DESC_OPTION({ | ||
| 952 | ("false", "No dynamic tearing."), | ||
| 953 | ("true", "Dynamic tearing for linear and nonlinear systems."), | ||
| 954 | ("linear", "Dynamic tearing only for linear systems."), | ||
| 955 | ("nonlinear", "Dynamic tearing only for nonlinear systems.") | ||
| 956 | })), | ||
| 957 | "Activates dynamic tearing (TearingSet can be changed automatically during runtime, strict set vs. casual set.)"); | ||
| 958 | constant ConfigFlag SYM_SOLVER = CONFIG_FLAG(59, "symSolver", | ||
| 959 | NONE(), EXTERNAL(), ENUM_FLAG(0, {("none",0), ("impEuler", 1), ("expEuler",2)}), NONE(), | ||
| 960 | "Activates symbolic implicit solver (original system is not changed)."); | ||
| 961 | constant ConfigFlag LOOP2CON = CONFIG_FLAG(60, "loop2con", | ||
| 962 | NONE(), EXTERNAL(), STRING_FLAG("none"), | ||
| 963 | SOME(STRING_DESC_OPTION({ | ||
| 964 | ("none", "Disables module"), | ||
| 965 | ("lin", "linear loops --> constraints"), | ||
| 966 | ("noLin", "no linear loops --> constraints"), | ||
| 967 | ("all", "loops --> constraints")})), | ||
| 968 | "Specifies method that transform loops in constraints. hint: using initial guess from file!"); | ||
| 969 | constant ConfigFlag FORCE_TEARING = CONFIG_FLAG(61, "forceTearing", | ||
| 970 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 971 | "Use tearing set even if it is not smaller than the original component."); | ||
| 972 | constant ConfigFlag SIMPLIFY_LOOPS = CONFIG_FLAG(62, "simplifyLoops", | ||
| 973 | NONE(), EXTERNAL(), INT_FLAG(0), | ||
| 974 | SOME(STRING_DESC_OPTION({ | ||
| 975 | ("0", "do nothing"), | ||
| 976 | ("1", "special modification of residual expressions"), | ||
| 977 | ("2", "special modification of residual expressions with helper variables") | ||
| 978 | })), | ||
| 979 | "Simplify algebraic loops."); | ||
| 980 | constant ConfigFlag RTEARING = CONFIG_FLAG(63, "recursiveTearing", | ||
| 981 | NONE(), EXTERNAL(), INT_FLAG(0), | ||
| 982 | SOME(STRING_DESC_OPTION({ | ||
| 983 | ("0", "do nothing"), | ||
| 984 | ("1", "linear tearing set of size 1"), | ||
| 985 | ("2", "linear tearing") | ||
| 986 | })), | ||
| 987 | "Inline and repeat tearing."); | ||
| 988 | constant ConfigFlag FLOW_THRESHOLD = CONFIG_FLAG(64, "flowThreshold", | ||
| 989 | NONE(), EXTERNAL(), REAL_FLAG(1e-7), NONE(), | ||
| 990 | "Sets the minium threshold for stream flow rates"); | ||
| 991 | constant ConfigFlag MATRIX_FORMAT = CONFIG_FLAG(65, "matrixFormat", | ||
| 992 | NONE(), EXTERNAL(), STRING_FLAG("dense"), NONE(), | ||
| 993 | "Sets the matrix format type in cpp runtime which should be used (dense | sparse ). Default: dense."); | ||
| 994 | constant ConfigFlag PARTLINTORN = CONFIG_FLAG(66, "partlintorn", | ||
| 995 | NONE(), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 996 | "Sets the limit for partitionin of linear torn systems."); | ||
| 997 | constant ConfigFlag INIT_OPT_MODULES = CONFIG_FLAG(67, "initOptModules", | ||
| 998 | NONE(), EXTERNAL(), STRING_LIST_FLAG({ | ||
| 999 | "simplifyComplexFunction", | ||
| 1000 | "tearingSystem", | ||
| 1001 | "solveSimpleEquations", | ||
| 1002 | "calculateStrongComponentJacobians", | ||
| 1003 | "simplifyAllExpressions", | ||
| 1004 | "collapseArrayExpressions" | ||
| 1005 | }), | ||
| 1006 | SOME(STRING_DESC_OPTION({ | ||
| 1007 | ("calculateStrongComponentJacobians", "Generates analytical jacobian for torn linear and non-linear strong components. By default linear components and non-linear components with user-defined function calls are skipped. See also debug flags: LSanalyticJacobian, NLSanalyticJacobian and forceNLSanalyticJacobian"), | ||
| 1008 | ("collapseArrayExpressions", collapseArrayExpressionsText), | ||
| 1009 | ("inlineArrayEqn", "This module expands all array equations to scalar equations."), | ||
| 1010 | ("constantLinearSystem", "Evaluates constant linear systems (a*x+b*y=c; d*x+e*y=f; a,b,c,d,e,f are constants) at compile-time."), | ||
| 1011 | ("extendDynamicOptimization", "Move loops to constraints."), | ||
| 1012 | ("generateHomotopyComponents", "Finds the parts of the DAE that have to be handled by the homotopy solver and creates a strong component out of it."), | ||
| 1013 | ("inlineHomotopy", "Experimental: Inlines the homotopy expression to allow symbolic simplifications."), | ||
| 1014 | ("inputDerivativesUsed", "Checks if derivatives of inputs are need to calculate the model."), | ||
| 1015 | ("recursiveTearing", "inline and repeat tearing"), | ||
| 1016 | ("reduceDynamicOptimization", "Removes equations which are not needed for the calculations of cost and constraints. This module requires --postOptModules+=reduceDynamicOptimization."), | ||
| 1017 | ("replaceHomotopyWithSimplified", "Replaces the homotopy expression homotopy(actual, simplified) with the simplified part."), | ||
| 1018 | ("simplifyAllExpressions", "Does simplifications on all expressions."), | ||
| 1019 | ("simplifyComplexFunction", "Some simplifications on complex functions (complex refers to the internal data structure)"), | ||
| 1020 | ("simplifyConstraints", "Rewrites nonlinear constraints into box constraints if possible. This module requires +gDynOpt."), | ||
| 1021 | ("simplifyLoops", "Simplifies algebraic loops. This modules requires +simplifyLoops."), | ||
| 1022 | ("solveSimpleEquations", "Solves simple equations"), | ||
| 1023 | ("tearingSystem", "For method selection use flag tearingMethod."), | ||
| 1024 | ("wrapFunctionCalls", "This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.") | ||
| 1025 | })), | ||
| 1026 | "Sets the initialization optimization modules to use in the back end. See --help=optmodules for more info."); | ||
| 1027 | constant ConfigFlag MAX_MIXED_DETERMINED_INDEX = CONFIG_FLAG(68, "maxMixedDeterminedIndex", | ||
| 1028 | NONE(), EXTERNAL(), INT_FLAG(10), NONE(), | ||
| 1029 | "Sets the maximum mixed-determined index that is handled by the initialization."); | ||
| 1030 | constant ConfigFlag USE_LOCAL_DIRECTION = CONFIG_FLAG(69, "useLocalDirection", | ||
| 1031 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1032 | "Keeps the input/output prefix for all variables in the flat model, not only top-level ones."); | ||
| 1033 | constant ConfigFlag DEFAULT_OPT_MODULES_ORDERING = CONFIG_FLAG(70, "defaultOptModulesOrdering", | ||
| 1034 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1035 | "If this is activated, then the specified pre-/post-/init-optimization modules will be rearranged to the recommended ordering."); | ||
| 1036 | constant ConfigFlag PRE_OPT_MODULES_ADD = CONFIG_FLAG(71, "preOptModules+", | ||
| 1037 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1038 | "Enables additional pre-optimization modules, e.g. --preOptModules+=module1,module2 would additionally enable module1 and module2. See --help=optmodules for more info."); | ||
| 1039 | constant ConfigFlag PRE_OPT_MODULES_SUB = CONFIG_FLAG(72, "preOptModules-", | ||
| 1040 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1041 | "Disables a list of pre-optimization modules, e.g. --preOptModules-=module1,module2 would disable module1 and module2. See --help=optmodules for more info."); | ||
| 1042 | constant ConfigFlag POST_OPT_MODULES_ADD = CONFIG_FLAG(73, "postOptModules+", | ||
| 1043 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1044 | "Enables additional post-optimization modules, e.g. --postOptModules+=module1,module2 would additionally enable module1 and module2. See --help=optmodules for more info."); | ||
| 1045 | constant ConfigFlag POST_OPT_MODULES_SUB = CONFIG_FLAG(74, "postOptModules-", | ||
| 1046 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1047 | "Disables a list of post-optimization modules, e.g. --postOptModules-=module1,module2 would disable module1 and module2. See --help=optmodules for more info."); | ||
| 1048 | constant ConfigFlag INIT_OPT_MODULES_ADD = CONFIG_FLAG(75, "initOptModules+", | ||
| 1049 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1050 | "Enables additional init-optimization modules, e.g. --initOptModules+=module1,module2 would additionally enable module1 and module2. See --help=optmodules for more info."); | ||
| 1051 | constant ConfigFlag INIT_OPT_MODULES_SUB = CONFIG_FLAG(76, "initOptModules-", | ||
| 1052 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1053 | "Disables a list of init-optimization modules, e.g. --initOptModules-=module1,module2 would disable module1 and module2. See --help=optmodules for more info."); | ||
| 1054 | constant ConfigFlag PERMISSIVE = CONFIG_FLAG(77, "permissive", | ||
| 1055 | NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1056 | "Disables some error checks to allow erroneous models to compile."); | ||
| 1057 | constant ConfigFlag HETS = CONFIG_FLAG(78, "hets", | ||
| 1058 | NONE(), INTERNAL(), STRING_FLAG("none"),SOME( | ||
| 1059 | STRING_DESC_OPTION({ | ||
| 1060 | ("none", "do nothing"), | ||
| 1061 | ("derCalls", "sort terms based on der-calls") | ||
| 1062 | })), | ||
| 1063 | "Heuristic equation terms sort"); | ||
| 1064 | constant ConfigFlag DEFAULT_CLOCK_PERIOD = CONFIG_FLAG(79, "defaultClockPeriod", | ||
| 1065 | NONE(), INTERNAL(), REAL_FLAG(1.0), NONE(), | ||
| 1066 | "Sets the default clock period (in seconds) for state machines (default: 1.0)."); | ||
| 1067 | constant ConfigFlag INST_CACHE_SIZE = CONFIG_FLAG(80, "instCacheSize", | ||
| 1068 | NONE(), EXTERNAL(), INT_FLAG(25343), NONE(), | ||
| 1069 | "Sets the size of the internal hash table used for instantiation caching."); | ||
| 1070 | constant ConfigFlag MAX_SIZE_LINEAR_TEARING = CONFIG_FLAG(81, "maxSizeLinearTearing", | ||
| 1071 | NONE(), EXTERNAL(), INT_FLAG(200), NONE(), | ||
| 1072 | "Sets the maximum system size for tearing of linear systems (default 200)."); | ||
| 1073 | constant ConfigFlag MAX_SIZE_NONLINEAR_TEARING = CONFIG_FLAG(82, "maxSizeNonlinearTearing", | ||
| 1074 | NONE(), EXTERNAL(), INT_FLAG(10000), NONE(), | ||
| 1075 | "Sets the maximum system size for tearing of nonlinear systems (default 10000)."); | ||
| 1076 | constant ConfigFlag NO_TEARING_FOR_COMPONENT = CONFIG_FLAG(83, "noTearingForComponent", | ||
| 1077 | NONE(), EXTERNAL(), INT_LIST_FLAG({}), NONE(), | ||
| 1078 | "Deactivates tearing for the specified components.\nUse '-d=tearingdump' to find out the relevant indexes."); | ||
| 1079 | constant ConfigFlag CT_STATE_MACHINES = CONFIG_FLAG(84, "ctStateMachines", | ||
| 1080 | NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1081 | "Experimental: Enable continuous-time state machine prototype"); | ||
| 1082 | constant ConfigFlag DAE_MODE = CONFIG_FLAG(85, "daeMode", | ||
| 1083 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1084 | "Generates code to simulate models in DAE mode. The whole system is passed directly to the DAE solver SUNDIALS/IDA and no algebraic solver is involved in the simulation process."); | ||
| 1085 | constant ConfigFlag INLINE_METHOD = CONFIG_FLAG(86, "inlineMethod", | ||
| 1086 | NONE(), EXTERNAL(), ENUM_FLAG(1, {("replace",1), ("append",2)}), NONE(), | ||
| 1087 | "Sets the inline method to use.\n"+ | ||
| 1088 | "replace : This method inlines by replacing in place all expressions. Might lead to very long expression.\n"+ | ||
| 1089 | "append : This method inlines by adding additional variables to the whole system. Might lead to much bigger system."); | ||
| 1090 | constant ConfigFlag SET_TEARING_VARS = CONFIG_FLAG(87, "setTearingVars", | ||
| 1091 | NONE(), EXTERNAL(), INT_LIST_FLAG({}), NONE(), | ||
| 1092 | "Sets the tearing variables by its strong component indexes. Use '-d=tearingdump' to find out the relevant indexes.\nUse following format: '--setTearingVars=(sci,n,t1,...,tn)*', with sci = strong component index, n = number of tearing variables, t1,...tn = tearing variables.\nE.g.: '--setTearingVars=4,2,3,5' would select variables 3 and 5 in strong component 4."); | ||
| 1093 | constant ConfigFlag SET_RESIDUAL_EQNS = CONFIG_FLAG(88, "setResidualEqns", | ||
| 1094 | NONE(), EXTERNAL(), INT_LIST_FLAG({}), NONE(), | ||
| 1095 | "Sets the residual equations by its strong component indexes. Use '-d=tearingdump' to find out the relevant indexes for the collective equations.\nUse following format: '--setResidualEqns=(sci,n,r1,...,rn)*', with sci = strong component index, n = number of residual equations, r1,...rn = residual equations.\nE.g.: '--setResidualEqns=4,2,3,5' would select equations 3 and 5 in strong component 4.\nOnly works in combination with 'setTearingVars'."); | ||
| 1096 | constant ConfigFlag IGNORE_COMMAND_LINE_OPTIONS_ANNOTATION = CONFIG_FLAG(89, "ignoreCommandLineOptionsAnnotation", | ||
| 1097 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1098 | "Ignores the command line options specified as annotation in the class."); | ||
| 1099 | constant ConfigFlag CALCULATE_SENSITIVITIES = CONFIG_FLAG(90, "calculateSensitivities", | ||
| 1100 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1101 | "Generates sensitivities variables and matrices."); | ||
| 1102 | constant ConfigFlag ALARM = CONFIG_FLAG(91, "alarm", | ||
| 1103 | SOME("r"), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 1104 | "Sets the number of seconds until omc times out. Used by the testing framework to terminate infinite running processes. The running command is first asked to stop, so that omc can still report how far it got; it exits outright a tenth of that time later (at least 5 and at most 60 seconds) if the command has no cancellation point to stop at."); | ||
| 1105 | constant ConfigFlag TOTAL_TEARING = CONFIG_FLAG(92, "totalTearing", | ||
| 1106 | NONE(), EXTERNAL(), INT_LIST_FLAG({}), NONE(), | ||
| 1107 | "Activates total tearing (determination of all possible tearing sets) for the specified components.\nUse '-d=tearingdump' to find out the relevant indexes."); | ||
| 1108 | constant ConfigFlag IGNORE_SIMULATION_FLAGS_ANNOTATION = CONFIG_FLAG(93, "ignoreSimulationFlagsAnnotation", | ||
| 1109 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1110 | "Ignores the simulation flags specified as annotation in the class."); | ||
| 1111 | constant ConfigFlag DYNAMIC_TEARING_FOR_INITIALIZATION = CONFIG_FLAG(94, "dynamicTearingForInitialization", | ||
| 1112 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1113 | "Enable Dynamic Tearing also for the initialization system."); | ||
| 1114 | constant ConfigFlag PREFER_TVARS_WITH_START_VALUE = CONFIG_FLAG(95, "preferTVarsWithStartValue", | ||
| 1115 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1116 | "Prefer tearing variables with start value for initialization."); | ||
| 1117 | constant ConfigFlag EQUATIONS_PER_FILE = CONFIG_FLAG(96, "equationsPerFile", | ||
| 1118 | NONE(), EXTERNAL(), INT_FLAG(500), NONE(), | ||
| 1119 | "Generate code for at most this many equations per C-file (partially implemented in the compiler)."); | ||
| 1120 | constant ConfigFlag EVALUATE_FINAL_PARAMS = CONFIG_FLAG(97, "evaluateFinalParameters", | ||
| 1121 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1122 | "Evaluates all the final parameters in addition to parameters with annotation(Evaluate=true)."); | ||
| 1123 | constant ConfigFlag EVALUATE_PROTECTED_PARAMS = CONFIG_FLAG(98, "evaluateProtectedParameters", | ||
| 1124 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1125 | "Evaluates all the protected parameters in addition to parameters with annotation(Evaluate=true)."); | ||
| 1126 | constant ConfigFlag REPLACE_EVALUATED_PARAMS = CONFIG_FLAG(99, "replaceEvaluatedParameters", | ||
| 1127 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1128 | "Replaces all the evaluated parameters in the DAE."); | ||
| 1129 | constant ConfigFlag CONDENSE_ARRAYS = CONFIG_FLAG(100, "condenseArrays", | ||
| 1130 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1131 | "Sets whether array expressions containing function calls are condensed or not."); | ||
| 1132 | constant ConfigFlag WFC_ADVANCED = CONFIG_FLAG(101, "wfcAdvanced", | ||
| 1133 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1134 | "wrapFunctionCalls ignores more then default cases, e.g. exp, sin, cos, log, (experimental flag)"); | ||
| 1135 | constant ConfigFlag GRAPHICS_EXP_MODE = CONFIG_FLAG(102, | ||
| 1136 | "graphicsExpMode", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1137 | "Sets whether we are in graphics exp mode (evaluating icons)."); | ||
| 1138 | constant ConfigFlag TEARING_STRICTNESS = CONFIG_FLAG(103, "tearingStrictness", | ||
| 1139 | NONE(), EXTERNAL(), STRING_FLAG("strict"),SOME( | ||
| 1140 | STRING_DESC_OPTION({ | ||
| 1141 | ("casual", "Loose tearing rules using ExpressionSolve to determine the solvability instead of considering the partial derivative. Allows to solve for everything that is analytically possible. This could lead to singularities during simulation."), | ||
| 1142 | ("strict", "Robust tearing rules by consideration of the partial derivative. Allows to divide by parameters that are not equal to or close to zero."), | ||
| 1143 | ("veryStrict", "Very strict tearing rules that do not allow to divide by any parameter. Use this if you aim at overriding parameters after compilation with values equal to or close to zero.") | ||
| 1144 | })), | ||
| 1145 | "Sets the strictness of the tearing method regarding the solvability restrictions."); | ||
| 1146 | constant ConfigFlag INTERACTIVE = CONFIG_FLAG(104, "interactive", | ||
| 1147 | NONE(), EXTERNAL(), STRING_FLAG("none"),SOME( | ||
| 1148 | STRING_DESC_OPTION({ | ||
| 1149 | ("none", "do nothing"), | ||
| 1150 | ("tcp", "Starts omc as a server listening on the socket interface."), | ||
| 1151 | ("zmq", "Starts omc as a ZeroMQ server listening on the socket interface.") | ||
| 1152 | })), | ||
| 1153 | "Sets the interactive mode for omc."); | ||
| 1154 | constant ConfigFlag ZEROMQ_FILE_SUFFIX = CONFIG_FLAG(105, "zeroMQFileSuffix", | ||
| 1155 | SOME("z"), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1156 | "Sets the file suffix for zeroMQ port file if --interactive=zmq is used."); | ||
| 1157 | constant ConfigFlag HOMOTOPY_APPROACH = CONFIG_FLAG(106, "homotopyApproach", | ||
| 1158 | NONE(), EXTERNAL(), STRING_FLAG("equidistantGlobal"), | ||
| 1159 | SOME(STRING_DESC_OPTION({ | ||
| 1160 | ("equidistantLocal", "Local homotopy approach with equidistant lambda steps. The homotopy parameter only effects the local strongly connected component."), | ||
| 1161 | ("adaptiveLocal", "Local homotopy approach with adaptive lambda steps. The homotopy parameter only effects the local strongly connected component."), | ||
| 1162 | ("equidistantGlobal", "Default, global homotopy approach with equidistant lambda steps. The homotopy parameter effects the entire initialization system."), | ||
| 1163 | ("adaptiveGlobal", "Global homotopy approach with adaptive lambda steps. The homotopy parameter effects the entire initialization system.") | ||
| 1164 | })), | ||
| 1165 | "Sets the homotopy approach."); | ||
| 1166 | constant ConfigFlag IGNORE_REPLACEABLE = CONFIG_FLAG(107, "ignoreReplaceable", | ||
| 1167 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1168 | "Sets whether to ignore replaceability or not when redeclaring."); | ||
| 1169 | constant ConfigFlag LABELED_REDUCTION = CONFIG_FLAG(108, | ||
| 1170 | "labeledReduction", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1171 | "Turns on labeling and reduce terms to do whole process of reduction."); | ||
| 1172 | constant ConfigFlag DISABLE_EXTRA_LABELING = CONFIG_FLAG(109, | ||
| 1173 | "disableExtraLabeling", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1174 | "Disable adding extra label into the whole expression with more than one term and +,- operations."); | ||
| 1175 | constant ConfigFlag LOAD_MSL_MODEL = CONFIG_FLAG(110, | ||
| 1176 | "loadMSLModel", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1177 | "Used to know loadFile doesn't need to be called in cpp-runtime (for labeled model reduction)."); | ||
| 1178 | constant ConfigFlag LOAD_PACKAGE_FILE = CONFIG_FLAG(111, | ||
| 1179 | "loadPackageFile", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1180 | "Used when the outside name is different with the inside name of the packge, in cpp-runtime (for labeled model reduction)."); | ||
| 1181 | constant ConfigFlag BUILDING_FMU = CONFIG_FLAG(112, | ||
| 1182 | "", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1183 | "Is true when building an FMU (so the compiler can look for URIs to package as FMI resources)."); | ||
| 1184 | constant ConfigFlag BUILDING_MODEL = CONFIG_FLAG(113, | ||
| 1185 | "", NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1186 | "Is true when building a model (as opposed to running a Modelica script)."); | ||
| 1187 | constant ConfigFlag POST_OPT_MODULES_DAE = CONFIG_FLAG(114, "postOptModulesDAE", | ||
| 1188 | NONE(), EXTERNAL(), STRING_LIST_FLAG({ | ||
| 1189 | "lateInlineFunction", | ||
| 1190 | "wrapFunctionCalls", | ||
| 1191 | //"replaceDerCalls", | ||
| 1192 | "simplifysemiLinear", | ||
| 1193 | "simplifyComplexFunction", | ||
| 1194 | "removeConstants", | ||
| 1195 | "simplifyTimeIndepFuncCalls", | ||
| 1196 | "simplifyAllExpressions", | ||
| 1197 | "findZeroCrossings", | ||
| 1198 | "createDAEmodeBDAE", | ||
| 1199 | "symbolicJacobianDAE", | ||
| 1200 | "setEvaluationStage" | ||
| 1201 | }),NONE(), | ||
| 1202 | "Sets the optimization modules for the DAEmode in the back end. See --help=optmodules for more info."); | ||
| 1203 | constant ConfigFlag EVAL_LOOP_LIMIT = CONFIG_FLAG(115, | ||
| 1204 | "evalLoopLimit", NONE(), EXTERNAL(), INT_FLAG(100000), NONE(), | ||
| 1205 | "The loop iteration limit used when evaluating constant function calls."); | ||
| 1206 | constant ConfigFlag EVAL_RECURSION_LIMIT = CONFIG_FLAG(116, | ||
| 1207 | "evalRecursionLimit", NONE(), EXTERNAL(), INT_FLAG(256), NONE(), | ||
| 1208 | "The recursion limit used when evaluating constant function calls."); | ||
| 1209 | constant ConfigFlag SINGLE_INSTANCE_AGLSOLVER = CONFIG_FLAG(117, "singleInstanceAglSolver", | ||
| 1210 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1211 | "Sets to instantiate only one algebraic loop solver all algebraic loops"); | ||
| 1212 | constant ConfigFlag SHOW_STRUCTURAL_ANNOTATIONS = CONFIG_FLAG(118, "showStructuralAnnotations", | ||
| 1213 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1214 | "Show annotations affecting the solution process in the flattened code."); | ||
| 1215 | constant ConfigFlag INITIAL_STATE_SELECTION = CONFIG_FLAG(119, "initialStateSelection", | ||
| 1216 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1217 | "Activates the state selection inside initialization to avoid singularities."); | ||
| 1218 | constant ConfigFlag LINEARIZATION_DUMP_LANGUAGE = CONFIG_FLAG(120, "linearizationDumpLanguage", | ||
| 1219 | NONE(), EXTERNAL(), STRING_FLAG("none"), | ||
| 1220 | SOME(STRING_DESC_OPTION({ | ||
| 1221 | ("none", "Don't generate code for linearization."), | ||
| 1222 | ("modelica", "Generate linearized Modelica model."), | ||
| 1223 | ("matlab", "Generate matlab function that returns linearization matrices A,B,C,D."), | ||
| 1224 | ("julia", "Generate julia function that returns linearization matrices A,B,C,D."), | ||
| 1225 | ("python", "Generate python function that returns linearization matrices A,B,C,D.")})), | ||
| 1226 | "Sets the target language for the produced code of linearization."); | ||
| 1227 | constant ConfigFlag NO_ASSC = CONFIG_FLAG(121, "noASSC", | ||
| 1228 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1229 | "Disables analytical to structural singularity conversion."); | ||
| 1230 | constant ConfigFlag FULL_ASSC = CONFIG_FLAG(122, "fullASSC", | ||
| 1231 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1232 | "Enables full equation replacement for BLT transformation from the ASSC algorithm."); | ||
| 1233 | constant ConfigFlag REAL_ASSC = CONFIG_FLAG(123, "realASSC", | ||
| 1234 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1235 | "Enables the ASSC algorithm to evaluate real valued coefficients (usually only integers)."); | ||
| 1236 | constant ConfigFlag INIT_ASSC = CONFIG_FLAG(124, "initASSC", | ||
| 1237 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1238 | "Enables the ASSC algorithm for initialization."); | ||
| 1239 | constant ConfigFlag MAX_SIZE_ASSC = CONFIG_FLAG(125, "maxSizeASSC", | ||
| 1240 | NONE(), EXTERNAL(), INT_FLAG(200), NONE(), | ||
| 1241 | "Sets the maximum system size for the analytical to structural conversion algorithm (default 200)."); | ||
| 1242 | constant ConfigFlag USE_ZEROMQ_IN_SIM = CONFIG_FLAG(126, "useZeroMQInSim", | ||
| 1243 | NONE(), INTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1244 | "Configures to use zeroMQ in simulation runtime to exchange information via ZeroMQ with other applications"); | ||
| 1245 | constant ConfigFlag ZEROMQ_PUB_PORT = CONFIG_FLAG(127, "zeroMQPubPort", | ||
| 1246 | NONE(), INTERNAL(), INT_FLAG(3203), NONE(), | ||
| 1247 | "Configures port number for simulation runtime to send information via ZeroMQ"); | ||
| 1248 | constant ConfigFlag ZEROMQ_SUB_PORT = CONFIG_FLAG(128, "zeroMQSubPort", | ||
| 1249 | NONE(), INTERNAL(), INT_FLAG(3204), NONE(), | ||
| 1250 | "Configures port number for simulation runtime to receive information via ZeroMQ"); | ||
| 1251 | constant ConfigFlag ZEROMQ_JOB_ID = CONFIG_FLAG(129, "zeroMQJOBID", | ||
| 1252 | NONE(), INTERNAL(), STRING_FLAG("empty"), NONE(), | ||
| 1253 | "Configures the ID with which the omc api call is labelled for zeroMQ communication."); | ||
| 1254 | constant ConfigFlag ZEROMQ_SERVER_ID = CONFIG_FLAG(130, "zeroMQServerID", | ||
| 1255 | NONE(), INTERNAL(), STRING_FLAG("empty"), NONE(), | ||
| 1256 | "Configures the ID with which server application is labelled for zeroMQ communication."); | ||
| 1257 | constant ConfigFlag ZEROMQ_CLIENT_ID = CONFIG_FLAG(131, "zeroMQClientID", | ||
| 1258 | NONE(), INTERNAL(), STRING_FLAG("empty"), NONE(), | ||
| 1259 | "Configures the ID with which the client application is labelled for zeroMQ communication."); | ||
| 1260 | constant ConfigFlag FMI_VERSION = CONFIG_FLAG(132, | ||
| 1261 | "", NONE(), INTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1262 | "returns the FMI Version either 1.0 or 2.0."); | ||
| 1263 | constant ConfigFlag BASE_MODELICA = CONFIG_FLAG(133, "baseModelica", | ||
| 1264 | SOME("f"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1265 | "Outputs experimental Base Modelica."); | ||
| 1266 | constant ConfigFlag FMI_FILTER = CONFIG_FLAG(134, "fmiFilter", NONE(), EXTERNAL(), | ||
| 1267 | ENUM_FLAG(FMI_PROTECTED, {("none", FMI_NONE), ("internal", FMI_INTERNAL), ("protected", FMI_PROTECTED), ("blackBox", FMI_BLACKBOX)}), | ||
| 1268 | SOME(STRING_DESC_OPTION({ | ||
| 1269 | ("none", "All variables are exposed, even variables introduced by the symbolic transformations. This is mainly for debugging purposes."), | ||
| 1270 | ("internal", "All model variables are exposed, including protected ones. Variables introduced by the symbolic transformations are filtered out, with minor exceptions, e.g. for state sets."), | ||
| 1271 | ("protected", "All public model variables are exposed. Internal and protected variables are filtered out, with small exceptions, e.g. for state sets."), | ||
| 1272 | ("blackBox", "Only the interface is exposed. All other variables are hidden or exposed with concealed names.") | ||
| 1273 | })), | ||
| 1274 | "Specifies which model variables are exposed by the modelDescription.xml"); | ||
| 1275 | constant ConfigFlag FMI_SOURCES = CONFIG_FLAG(135, "fmiSources", NONE(), EXTERNAL(), | ||
| 1276 | ENUM_FLAG(FMI_SOURCES_NONE, {("false", FMI_SOURCES_NONE), ("true", FMI_SOURCES_SLIM), | ||
| 1277 | ("slim", FMI_SOURCES_SLIM), ("full", FMI_SOURCES_FULL)}), | ||
| 1278 | SOME(STRING_DESC_OPTION({ | ||
| 1279 | ("false", "The FMU carries no sources at all [default]."), | ||
| 1280 | ("true", "Same as slim."), | ||
| 1281 | ("slim", "The FMU carries the sources it was built from. Under --simCodeTarget=C that is a mix of C and Rust, and rebuilding needs cargo to fetch the Rust dependencies from crates.io."), | ||
| 1282 | ("full", "As slim, plus a vendored copy of the Rust dependencies, so the FMU rebuilds without network access. Only differs from slim under --simCodeTarget=C.") | ||
| 1283 | })), | ||
| 1284 | "Defines how much source code FMUs will be exported with. --fmiFilter=blackBox might override this, because black box FMUs do never contain their source code."); | ||
| 1285 | constant ConfigFlag FMI_FLAGS = CONFIG_FLAG(136, "fmiFlags", NONE(), EXTERNAL(), | ||
| 1286 | STRING_LIST_FLAG({}), NONE(), | ||
| 1287 | "Add simulation flags to FMU. Will create <fmiPrefix>_flags.json in resources folder with given flags. Use --fmiFlags or --fmiFlags=none to disable [default]. Use --fmiFlags=default for the default simulation flags. To pass flags use e.g. --fmiFlags=s:cvode,nls:homotopy or --fmiFlags=path/to/yourFlags.json."); | ||
| 1288 | constant ConfigFlag FMU_CMAKE_BUILD = CONFIG_FLAG(137, "fmuCMakeBuild", | ||
| 1289 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1290 | "Deprecated and ignored. Source-code FMUs are always built with CMake."); | ||
| 1291 | constant ConfigFlag NEW_BACKEND = CONFIG_FLAG(138, "newBackend", | ||
| 1292 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1293 | "Activates experimental new backend for better array handling. This also activates the new frontend. [WIP]"); | ||
| 1294 | constant ConfigFlag PARMODAUTO = CONFIG_FLAG(139, "parmodauto", | ||
| 1295 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1296 | "Experimental: Enable parallelization of independent systems of equations in the translated model. Only works on Linux systems."); | ||
| 1297 | constant ConfigFlag INTERACTIVE_PORT = CONFIG_FLAG(140, "interactivePort", | ||
| 1298 | NONE(), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 1299 | "Sets the port used by the interactive server."); | ||
| 1300 | constant ConfigFlag ALLOW_NON_STANDARD_MODELICA = CONFIG_FLAG(141, "allowNonStandardModelica", | ||
| 1301 | NONE(), EXTERNAL(), STRING_LIST_FLAG({ | ||
| 1302 | }), | ||
| 1303 | SOME(STRING_DESC_OPTION({ | ||
| 1304 | ("nonStdMultipleExternalDeclarations", "Allow several external declarations in functions.\nSee: https://specification.modelica.org/maint/3.5/functions.html#function-as-a-specialized-class"), | ||
| 1305 | ("nonStdEnumerationAsIntegers", "Allow enumeration as integer without casting via Integer(Enum).\nSee: https://specification.modelica.org/maint/3.5/class-predefined-types-and-declarations.html#type-conversion-of-enumeration-values-to-string-or-integer"), | ||
| 1306 | ("nonStdIntegersAsEnumeration", "Allow integer as enumeration without casting via Enum(Integer).\nSee: https://specification.modelica.org/maint/3.5/class-predefined-types-and-declarations.html#type-conversion-of-integer-to-enumeration-values"), | ||
| 1307 | ("nonStdDifferentCaseFileVsClassName", "Allow directory or file with different case in the name than the contained class name.\nSee: https://specification.modelica.org/maint/3.5/packages.html#mapping-package-class-structures-to-a-hierarchical-file-system"), | ||
| 1308 | ("nonStdTopLevelOuter", "Allow top level outer.\nSee: https://specification.modelica.org/maint/3.6/scoping-name-lookup-and-flattening.html#S4.p1"), | ||
| 1309 | ("protectedAccess", "Allow access of protected elements"), | ||
| 1310 | ("reinitInAlgorithms", "Allow reinit in algorithm sections"), | ||
| 1311 | ("unbalancedModel", "Allow models to be locally unbalanced and to have unbalanced connectors"), | ||
| 1312 | ("implicitParameterStartAttribute", "Allow fixed parameters with no binding or start attribute"), | ||
| 1313 | ("initialSimplified", "Allow use of experimental operator `initialSimplified()`"), | ||
| 1314 | ("illegalConditionalContext", "Allow use of components with false conditions in illegal contexts") | ||
| 1315 | })), | ||
| 1316 | "Flags to allow non-standard Modelica."); | ||
| 1317 | constant ConfigFlag EXPORT_CLOCKS_IN_MODELDESCRIPTION = CONFIG_FLAG(142, "exportClocksInModelDescription", | ||
| 1318 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1319 | "exports clocks in modeldescription.xml for fmus, The default is false."); | ||
| 1320 | constant ConfigFlag LINK_TYPE = CONFIG_FLAG(143, "linkType", | ||
| 1321 | NONE(), EXTERNAL(), ENUM_FLAG(1, {("dynamic",1), ("static",2)}), NONE(), | ||
| 1322 | "Sets the link type for the simulation executable.\n"+ | ||
| 1323 | "dynamic: libraries are dynamically linked; the executable is built very fast but is not portable because of DLL dependencies.\n"+ | ||
| 1324 | "static: libraries are statically linked; the executable is built more slowly but it is portable and dependency-free.\n"); | ||
| 1325 | constant ConfigFlag TEARING_ALWAYS_DERIVATIVES = CONFIG_FLAG(144, "tearingAlwaysDer", | ||
| 1326 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1327 | "Always choose state derivatives as iteration variables in strong components."); | ||
| 1328 | constant ConfigFlag DUMP_FLAT_MODEL = CONFIG_FLAG(145, "dumpFlatModel", | ||
| 1329 | NONE(), EXTERNAL(), STRING_LIST_FLAG({"all"}), | ||
| 1330 | SOME(STRING_DESC_OPTION({ | ||
| 1331 | ("flatten", "After flattening but before connection handling."), | ||
| 1332 | ("connections", "After connection handling."), | ||
| 1333 | ("eval", "After evaluating constants."), | ||
| 1334 | ("simplify", "After model simplification."), | ||
| 1335 | ("scalarize", "After scalarizing arrays."), | ||
| 1336 | ("translateResidualsDAE", "Show the result of the translateResidualsDAE API.") | ||
| 1337 | })), | ||
| 1338 | "Dumps the flat model at the given stages of the frontend."); | ||
| 1339 | constant ConfigFlag SIMULATION = CONFIG_FLAG(146, "simulation", | ||
| 1340 | SOME("u"), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1341 | "Simulates the last model in the given Modelica file."); | ||
| 1342 | constant ConfigFlag OBFUSCATE = CONFIG_FLAG(147, "obfuscate", | ||
| 1343 | NONE(), EXTERNAL(), STRING_FLAG("none"), | ||
| 1344 | SOME(STRING_DESC_OPTION({ | ||
| 1345 | ("none", "No obfuscation."), | ||
| 1346 | ("encrypted", "Obfuscates protected variables in encrypted models"), | ||
| 1347 | ("protected", "Obfuscates protected variables in all models."), | ||
| 1348 | ("full", "Obfuscates everything.") | ||
| 1349 | })), | ||
| 1350 | "Obfuscates identifiers in the simulation model"); | ||
| 1351 | constant ConfigFlag FMU_RUNTIME_DEPENDS = CONFIG_FLAG(148, "fmuRuntimeDepends", | ||
| 1352 | NONE(), EXTERNAL(), STRING_FLAG("default"), | ||
| 1353 | SOME(STRING_DESC_OPTION({ | ||
| 1354 | ("default", "Depending on CMake version. If CMake version >= 3.21 use \"modelica\", otherwise use \"none\""), | ||
| 1355 | ("none", "No runtime library dependencies are copied into the FMU."), | ||
| 1356 | ("modelica", "All modelica runtime library dependencies are copied into the FMU." + | ||
| 1357 | "System librarys located in '/lib*', '/usr/lib*' and '/usr/local/lib*' are excluded." + | ||
| 1358 | "Needs CMake version >= 3.21."), | ||
| 1359 | ("all", "All runtime library dependencies are copied into the FMU." + | ||
| 1360 | "System librarys are copied as well." + | ||
| 1361 | "Needs CMake version >= 3.21.") | ||
| 1362 | })), | ||
| 1363 | "Defines if runtime library dependencies are included in the FMU."); | ||
| 1364 | constant ConfigFlag FRONTEND_INLINE = CONFIG_FLAG(149, "frontendInline", | ||
| 1365 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1366 | "Enables inlining of functions in the frontend."); | ||
| 1367 | constant ConfigFlag EXPOSE_LOCAL_IOS = CONFIG_FLAG(150, "exposeLocalIOs", | ||
| 1368 | NONE(), EXTERNAL(), INT_FLAG(0), NONE(), | ||
| 1369 | "Introduces top-level inputs/outputs for unconnected input/output connectors at requested levels, provided they are public, " + | ||
| 1370 | "0 meaning top-level (standard Modelica), 1 inputs/outputs of top-level components, >1 going deeper. " + | ||
| 1371 | "This flag is particularly useful for FMI export."); | ||
| 1372 | constant ConfigFlag BASE_MODELICA_FORMAT = CONFIG_FLAG(151, "baseModelicaFormat", | ||
| 1373 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), SOME(STRING_DESC_OPTION({ | ||
| 1374 | ("scalarized", "Include subscripts in the quoted identifiers ('a[1].x[3]')."), | ||
| 1375 | ("partiallyScalarized", "Include subscripts in the quoted identifiers, except for the last name ('a[1].x'[3])."), | ||
| 1376 | ("nonScalarized", "Don't include subscripts in the quoted identifiers ('a'[1].'x'[3])."), | ||
| 1377 | ("withRecords", "Keep records and don't expand them."), | ||
| 1378 | ("withoutRecords", "Expand records into separate components."), | ||
| 1379 | ("showConfidence", "Add comments that show confidence numbers for binding equations.") | ||
| 1380 | })), | ||
| 1381 | "Formatting options for Base Modelica"); | ||
| 1382 | constant ConfigFlag BASE_MODELICA_OPTIONS = CONFIG_FLAG(152, "baseModelicaOptions", | ||
| 1383 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), SOME(STRING_DESC_OPTION({ | ||
| 1384 | ("moveBindings", "Moves movable binding equations to normal equations."), | ||
| 1385 | ("scalarize", "Fully scalarize the Base Modelica model."), | ||
| 1386 | ("inlineFunctions", "Inline all functions.") | ||
| 1387 | })), | ||
| 1388 | "Enables optional Base Modelica options."); | ||
| 1389 | constant ConfigFlag DEBUG_FOLLOW_EQUATIONS = CONFIG_FLAG(153, "debugFollowEquations", | ||
| 1390 | NONE(), EXTERNAL(), STRING_LIST_FLAG({}), NONE(), | ||
| 1391 | "Takes a list of equation names and prints the corresponding equations after each stage of the backend process."); | ||
| 1392 | constant ConfigFlag MAX_SIZE_LINEARIZATION = CONFIG_FLAG(154, "maxSizeLinearization", | ||
| 1393 | NONE(), EXTERNAL(), INT_FLAG(1000), NONE(), | ||
| 1394 | "Sets the maximum system size for which linearization code is generated."); | ||
| 1395 | constant ConfigFlag RESIZABLE_ARRAYS = CONFIG_FLAG(155, "resizableArrays", | ||
| 1396 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1397 | "Assumes all arrays are resizable. Only works with the new backend --newBackend."); | ||
| 1398 | constant ConfigFlag EVALUATE_STRUCTURAL_PARAMETERS = CONFIG_FLAG(156, "evaluateStructuralParameters", | ||
| 1399 | NONE(), EXTERNAL(), STRING_FLAG("all"), | ||
| 1400 | SOME(STRING_DESC_OPTION({ | ||
| 1401 | ("all", "Evaluates all structural parameters"), | ||
| 1402 | ("strictlyNecessary", "Evaluates only structural parameters strictly required by the frontend") | ||
| 1403 | })), | ||
| 1404 | "Sets which structural parameters are evaluated by the frontend."); | ||
| 1405 | constant ConfigFlag LOAD_MISSING_LIBRARIES = CONFIG_FLAG(157, "loadMissingLibraries", | ||
| 1406 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1407 | "Automatically try to load a matching library if a name can't be found during name lookup."); | ||
| 1408 | constant ConfigFlag CAUSALIZE_DAE_MODE = CONFIG_FLAG(158, "causalizeDaeMode", | ||
| 1409 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1410 | "The system is partially causalized and simple assignments are generated for equations that can be solved explicitly. Only works with --daeMode."); | ||
| 1411 | /* please remove me once this is supported */ | ||
| 1412 | constant ConfigFlag SIM_CODE_SCALARIZE = CONFIG_FLAG(159, "simCodeScalarize", | ||
| 1413 | NONE(), EXTERNAL(), BOOL_FLAG(true), NONE(), | ||
| 1414 | "Scalarizes variables during simcode phase."); | ||
| 1415 | constant ConfigFlag EXECUTE_COMMAND = CONFIG_FLAG(160, "cmd", | ||
| 1416 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1417 | "Executes the string argument as a script before any other operation."); | ||
| 1418 | constant ConfigFlag MOO_DYNAMIC_OPTIMIZATION = CONFIG_FLAG(161, "moo", | ||
| 1419 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1420 | "Generate code for dynamic optimization library MOO."); | ||
| 1421 | constant ConfigFlag FMI_EXTRA_ANNOTATIONS = CONFIG_FLAG(162, "fmiExtraAnnotations", | ||
| 1422 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1423 | "Export annotations matching the given regex to extra/org.openmodelica/modelAnnotations.json."); | ||
| 1424 | constant Integer IDUMP_DEFAULT = 0; | ||
| 1425 | constant Integer IDUMP_JSON = 1; | ||
| 1426 | constant ConfigFlag INTERACTIVE_DUMP_FORMAT = CONFIG_FLAG(163, "interactiveDumpFormat", | ||
| 1427 | NONE(), EXTERNAL(), ENUM_FLAG(IDUMP_DEFAULT, {("default", IDUMP_DEFAULT), ("json", IDUMP_JSON)}), NONE(), | ||
| 1428 | "Selects the format interactive API calls use to print result values.\n"+ | ||
| 1429 | "default : The OpenModelica textual value format.\n"+ | ||
| 1430 | "json : JSON, for programmatic consumers such as the web clients."); | ||
| 1431 | constant ConfigFlag EXPORT_FMU = CONFIG_FLAG(164, "export-fmu", | ||
| 1432 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1433 | "Export the model as an FMU after loading. Combine with --fmuType and --fmuPlatforms to configure the export."); | ||
| 1434 | constant ConfigFlag FMU_TYPE = CONFIG_FLAG(165, "fmuType", | ||
| 1435 | NONE(), EXTERNAL(), STRING_LIST_FLAG({"me"}), NONE(), | ||
| 1436 | "FMI type for FMU export: me, cs, me_cs, se."); | ||
| 1437 | constant ConfigFlag FMU_PLATFORMS = CONFIG_FLAG(166, "fmuPlatforms", | ||
| 1438 | NONE(), EXTERNAL(), STRING_FLAG("static"), NONE(), | ||
| 1439 | "Platforms for FMU export, comma-separated (e.g. static,dynamic)."); | ||
| 1440 | constant ConfigFlag FMU_VERSION = CONFIG_FLAG(167, "fmiVersion", | ||
| 1441 | NONE(), EXTERNAL(), ENUM_FLAG(FMI_VERSION_20, {("1.0", FMI_VERSION_10), ("2.0", FMI_VERSION_20), ("3.0", FMI_VERSION_30)}), | ||
| 1442 | SOME(STRING_OPTION({"1.0", "2.0", "3.0"})), | ||
| 1443 | "FMI version for FMU export: 1.0, 2.0, 3.0."); | ||
| 1444 | constant ConfigFlag TEARING_COST_MARGIN = CONFIG_FLAG(168, "tearingCostMargin", | ||
| 1445 | NONE(), EXTERNAL(), REAL_FLAG(2.0), NONE(), | ||
| 1446 | "How much cheaper solving a linear system untorn has to be estimated before its\ntearing set is dropped. Raise it to keep tearing systems the estimate would give\nup on, lower it towards 0 to tear less (default 2)."); | ||
| 1447 | constant ConfigFlag FMU_NATIVE_PLATFORMS = CONFIG_FLAG(169, | ||
| 1448 | "", NONE(), INTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1449 | "buildModelFMU's non-wasm platforms, comma separated: the wasm FMU also carries | ||
| 1450 | a precompiled artifact and a loader library for each of them."); | ||
| 1451 | constant ConfigFlag TPL_OUTPUT_DIR = CONFIG_FLAG(170, "tplOutputDir", | ||
| 1452 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1453 | "Directory the .mo generated from a Susan .tpl is written to. Empty (the\ndefault) writes it next to the .tpl, which is how the templates used to be\ngenerated into the source tree."); | ||
| 1454 | constant ConfigFlag FMU_DIRECTORY = CONFIG_FLAG(171, "fmuDirectory", | ||
| 1455 | NONE(), EXTERNAL(), BOOL_FLAG(false), NONE(), | ||
| 1456 | "Write an exported FMU as an unzipped directory named <prefix>.fmu rather than\na zip file. An importer that reads a directory (OpenModelica's own does) then\npays neither the compression nor the extraction, which for a wasm FMU carrying a\nprecompiled artifact is most of what packing it costs. wasm FMUs only."); | ||
| 1457 | constant ConfigFlag TPL_INTERFACE_DIR = CONFIG_FLAG(172, "tplInterfaceDir", | ||
| 1458 | NONE(), EXTERNAL(), STRING_FLAG(""), NONE(), | ||
| 1459 | "Directory searched before the current one for the interface files a Susan\n.tpl imports with 'import interface'."); | ||
| 1460 | |||
| 1461 | function getFlags | ||
| 1462 | "Loads the flags with getGlobalRoot. Assumes flags have been loaded." | ||
| 1463 | input Boolean initialize = true; | ||
| 1464 | output Flag flags; | ||
| 1465 | algorithm | ||
| 1466 | /* FlagsUtil.loadFlags does more, but depends on Error, which depends on Flags */ | ||
| 1467 | 90957977 | flags := getGlobalRoot(Global.flagsIndex); | |
| 1468 | end getFlags; | ||
| 1469 | |||
| 1470 | function isSet | ||
| 1471 | "Checks if a debug flag is set." | ||
| 1472 | input DebugFlag inFlag; | ||
| 1473 | output Boolean outValue; | ||
| 1474 | protected | ||
| 1475 | array<Boolean> debug_flags; | ||
| 1476 | Flag flags; | ||
| 1477 | Integer index; | ||
| 1478 | algorithm | ||
| 1479 | 43929216 | DEBUG_FLAG(index = index) := inFlag; | |
| 1480 | 43929216 | flags := getFlags(); | |
| 1481 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 43929216 times.
|
43929216 | FLAGS(debugFlags = debug_flags) := flags; |
| 1482 | 43929216 | outValue := arrayGet(debug_flags, index); | |
| 1483 | end isSet; | ||
| 1484 | |||
| 1485 | function isConfigFlagSet | ||
| 1486 | "Checks if a string list config flag contains a certain string" | ||
| 1487 | input ConfigFlag inFlag "the flag with the list of strings"; | ||
| 1488 | input String hasMember "the string to check for membership"; | ||
| 1489 | output Boolean isMember; | ||
| 1490 | algorithm | ||
| 1491 | 96661 | isMember := listMember(hasMember, Flags.getConfigStringList(inFlag)); | |
| 1492 | end isConfigFlagSet; | ||
| 1493 | |||
| 1494 | public function getConfigName | ||
| 1495 | "Returns name of configuration flag" | ||
| 1496 | input ConfigFlag inFlag; | ||
| 1497 | output String name; | ||
| 1498 | algorithm | ||
| 1499 | ✗ | CONFIG_FLAG(name = name) := inFlag; | |
| 1500 | end getConfigName; | ||
| 1501 | |||
| 1502 | public function getConfigValue | ||
| 1503 | "Returns the value of a configuration flag." | ||
| 1504 | input ConfigFlag inFlag; | ||
| 1505 | output FlagData outValue; | ||
| 1506 | protected | ||
| 1507 | array<FlagData> config_flags; | ||
| 1508 | Integer index; | ||
| 1509 | Flag flags; | ||
| 1510 | String name; | ||
| 1511 | algorithm | ||
| 1512 | 46906146 | CONFIG_FLAG(name = name, index = index) := inFlag; | |
| 1513 | 46906146 | flags := getFlags(); | |
| 1514 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46906146 times.
|
46906146 | FLAGS(configFlags = config_flags) := flags; |
| 1515 | 46906146 | outValue := arrayGet(config_flags, index); | |
| 1516 | end getConfigValue; | ||
| 1517 | |||
| 1518 | function getConfigBool | ||
| 1519 | "Returns the value of a boolean configuration flag." | ||
| 1520 | input ConfigFlag inFlag; | ||
| 1521 | output Boolean outValue; | ||
| 1522 | algorithm | ||
| 1523 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 24164819 times.
|
24164819 | BOOL_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1524 | end getConfigBool; | ||
| 1525 | |||
| 1526 | function getConfigInt | ||
| 1527 | "Returns the value of an integer configuration flag." | ||
| 1528 | input ConfigFlag inFlag; | ||
| 1529 | output Integer outValue; | ||
| 1530 | algorithm | ||
| 1531 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 299369 times.
|
299369 | INT_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1532 | end getConfigInt; | ||
| 1533 | |||
| 1534 | function getConfigIntList | ||
| 1535 | "Returns the value of an integer configuration flag." | ||
| 1536 | input ConfigFlag inFlag; | ||
| 1537 | output list<Integer> outValue; | ||
| 1538 | algorithm | ||
| 1539 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8104 times.
|
8104 | INT_LIST_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1540 | end getConfigIntList; | ||
| 1541 | |||
| 1542 | function getConfigReal | ||
| 1543 | "Returns the value of a real configuration flag." | ||
| 1544 | input ConfigFlag inFlag; | ||
| 1545 | output Real outValue; | ||
| 1546 | algorithm | ||
| 1547 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4409 times.
|
4409 | REAL_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1548 | end getConfigReal; | ||
| 1549 | |||
| 1550 | function getConfigString | ||
| 1551 | "Returns the value of a string configuration flag." | ||
| 1552 | input ConfigFlag inFlag; | ||
| 1553 | output String outValue; | ||
| 1554 | algorithm | ||
| 1555 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6977747 times.
|
6977747 | STRING_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1556 | end getConfigString; | ||
| 1557 | |||
| 1558 | function getConfigStringList | ||
| 1559 | "Returns the value of a multiple-string configuration flag." | ||
| 1560 | input ConfigFlag inFlag; | ||
| 1561 | output list<String> outValue; | ||
| 1562 | algorithm | ||
| 1563 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 139031 times.
|
139031 | STRING_LIST_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1564 | end getConfigStringList; | ||
| 1565 | |||
| 1566 | function getConfigEnum | ||
| 1567 | "Returns the value of an enumeration configuration flag." | ||
| 1568 | input ConfigFlag inFlag; | ||
| 1569 | output Integer outValue; | ||
| 1570 | algorithm | ||
| 1571 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 15312667 times.
|
15312667 | ENUM_FLAG(data = outValue) := getConfigValue(inFlag); |
| 1572 | end getConfigEnum; | ||
| 1573 | |||
| 1574 | annotation(__OpenModelica_Interface="util"); | ||
| 1575 | end Flags; | ||
| 1576 |