.. _openmodelica-compiler-flags :

OpenModelica Compiler Flags
===========================
Usage: omc [Options] (Model.mo | Script.mos) [Libraries | .mo-files]

* Libraries: Fully qualified names of libraries to load before processing Model or Script.
  The libraries should be separated by spaces: Lib1 Lib2 ... LibN.


.. _omcflags-options :

Options
-------

.. _omcflag-debug:

:ref:`-d, --debug<omcflag-debug>`

Sets debug flags. Use :ref:`--help=debug <omcflag-debug-section>` to see available flags.

String list (default *empty*).

.. _omcflag-help:

:ref:`-h, --help<omcflag-help>`

Displays the help text. Use --help=topics for more information.

String (default *empty*).

.. _omcflag-version:

:ref:`--v, --version<omcflag-version>`

Print the version and exit.

Boolean (default ``false``).

.. _omcflag-target:

:ref:`--target<omcflag-target>`

Sets the target compiler to use.

String (default gcc). Valid options:

* gcc
* msvc
* msvc10
* msvc12
* msvc13
* msvc15
* msvc19
* vxworks69
* debugrt

.. _omcflag-grammar:

:ref:`-g, --grammar<omcflag-grammar>`

Sets the grammar and semantics to accept.

String (default  Modelica). Valid options:

* Modelica
* MetaModelica
* ParModelica
* Optimica
* PDEModelica

.. _omcflag-annotationVersion:

:ref:`--annotationVersion<omcflag-annotationVersion>`

Sets the annotation version that should be used.

String (default 3.x). Valid options:

* 1.x
* 2.x
* 3.x

.. _omcflag-std:

:ref:`--std<omcflag-std>`

Sets the language standard that should be used.

String (default  latest). Valid options:

* 1.x
* 2.x
* 3.1
* 3.2
* 3.3
* 3.4
* 3.5
* latest
* experimental

.. _omcflag-showErrorMessages:

:ref:`--showErrorMessages<omcflag-showErrorMessages>`

Show error messages immediately when they happen.

Boolean (default ``false``).

.. _omcflag-showAnnotations:

:ref:`--showAnnotations<omcflag-showAnnotations>`

Show annotations in the flattened code.

Boolean (default ``false``).

.. _omcflag-noSimplify:

:ref:`--noSimplify<omcflag-noSimplify>`

Do not simplify expressions if set.

Boolean (default ``false``).

.. _omcflag-preOptModules:

:ref:`--preOptModules<omcflag-preOptModules>`

Sets the pre optimization modules to use in the back end. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default normalInlineFunction,evaluateParameters,simplifyIfEquations,expandDerOperator,clockPartitioning,findStateOrder,replaceEdgeChange,inlineArrayEqn,removeEqualRHS,removeSimpleEquations,comSubExp,resolveLoops,evalFunc,encapsulateWhenConditions). Valid options:

* introduceOutputAliases (Introduces aliases for top-level outputs.)
* clockPartitioning (Does the clock partitioning.)
* collapseArrayExpressions (Simplifies {x[1],x[2],x[3]} → x for arrays of whole variable references (simplifies code generation).)
* comSubExp (Introduces alias assignments for variables which are assigned to simple terms i.e. a = b/c; d = b/c; --> a=d)
* dumpDAE (dumps the DAE representation of the current transformation state)
* dumpDAEXML (dumps the DAE as xml representation of the current transformation state)
* encapsulateWhenConditions (This module replaces each when condition with a boolean variable.)
* evalFunc (evaluates functions partially)
* 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.)
* expandDerOperator (Expands der(expr) using Derive.differentiteExpTime.)
* findStateOrder (Sets derivative information to states.)
* inlineArrayEqn (This module expands all array equations to scalar equations.)
* normalInlineFunction (Perform function inlining for function with annotation Inline=true.)
* inputDerivativesForDynOpt (Allowed derivatives of inputs in dyn. optimization.)
* introduceDerAlias (Adds for every der-call an alias equation e.g. dx = der(x).)
* removeEqualRHS (Detects equal expressions of the form a=<exp> and b=<exp> and substitutes them to get speed up.)
* removeProtectedParameters (Replace all parameters with protected=true in the system.)
* removeSimpleEquations (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).)
* removeUnusedParameter (Strips all parameter not present in the equations from the system.)
* removeUnusedVariables (Strips all variables not present in the equations from the system.)
* 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.)
* replaceEdgeChange (Replace edge(b) = b and not pre(b) and change(b) = v <> pre(v).)
* residualForm (Transforms simple equations x=y to zero-sum equations 0=y-x.)
* resolveLoops (resolves linear equations in loops)
* simplifyAllExpressions (Does simplifications on all expressions.)
* simplifyIfEquations (Tries to simplify if equations by use of information from evaluated parameters.)
* sortEqnsVars (Heuristic sorting for equations and variables.)
* unitChecking (This module is no longer available and its use is deprecated. Use --unitChecking instead.)
* wrapFunctionCalls (This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.)

.. _omcflag-cheapmatchingAlgorithm:

:ref:`--cheapmatchingAlgorithm<omcflag-cheapmatchingAlgorithm>`

Sets the cheap matching algorithm to use. A cheap matching algorithm gives a jump start matching by heuristics.

Integer (default ``3``). Valid options:

* 0 (No cheap matching.)
* 1 (Cheap matching, traverses all equations and match the first free variable.)
* 3 (Random Karp-Sipser: R. M. Karp and M. Sipser. Maximum matching in sparse random graphs.)

.. _omcflag-matchingAlgorithm:

:ref:`--matchingAlgorithm<omcflag-matchingAlgorithm>`

Sets the matching algorithm to use. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String (default PFPlusExt). Valid options:

* BFSB (Breadth First Search based algorithm.)
* DFSB (Depth First Search based algorithm.)
* MC21A (Depth First Search based algorithm with look ahead feature.)
* PF (Depth First Search based algorithm with look ahead feature.)
* PFPlus (Depth First Search based algorithm with look ahead feature and fair row traversal.)
* HK (Combined BFS and DFS algorithm.)
* HKDW (Combined BFS and DFS algorithm.)
* ABMP (Combined BFS and DFS algorithm.)
* PR (Matching algorithm using push relabel mechanism.)
* DFSBExt (Depth First Search based Algorithm external c implementation.)
* BFSBExt (Breadth First Search based Algorithm external c implementation.)
* MC21AExt (Depth First Search based Algorithm with look ahead feature external c implementation.)
* PFExt (Depth First Search based Algorithm with look ahead feature external c implementation.)
* PFPlusExt (Depth First Search based Algorithm with look ahead feature and fair row traversal external c implementation.)
* HKExt (Combined BFS and DFS algorithm external c implementation.)
* HKDWExt (Combined BFS and DFS algorithm external c implementation.)
* ABMPExt (Combined BFS and DFS algorithm external c implementation.)
* PRExt (Matching algorithm using push relabel mechanism external c implementation.)
* BB (BBs try.)
* SBGraph (Set-Based Graph matching algorithm for efficient array handling.)
* pseudo (Pseudo array matching that uses scalar matching and reconstructs arrays afterwards as much as possible.)

.. _omcflag-indexReductionMethod:

:ref:`--indexReductionMethod<omcflag-indexReductionMethod>`

Sets the index reduction method to use. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String (default dynamicStateSelection). Valid options:

* none (Skip index reduction)
* uode (Use the underlying ODE without the constraints.)
* dynamicStateSelection (Simple index reduction method, select (dynamic) dummy states based on analysis of the system.)
* dummyDerivatives (Simple index reduction method, select (static) dummy states based on heuristic.)

.. _omcflag-postOptModules:

:ref:`--postOptModules<omcflag-postOptModules>`

Sets the post optimization modules to use in the back end. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default lateInlineFunction,wrapFunctionCalls,inlineArrayEqn,constantLinearSystem,simplifysemiLinear,removeSimpleEquations,simplifyComplexFunction,solveSimpleEquations,tearingSystem,inputDerivativesUsed,calculateStrongComponentJacobians,calculateStateSetsJacobians,symbolicJacobian,removeConstants,simplifyTimeIndepFuncCalls,simplifyAllExpressions,findZeroCrossings,collapseArrayExpressions). Valid options:

* addScaledVars_states (added var_norm = var/nominal, where var is state)
* addScaledVars_inputs (added var_norm = var/nominal, where var is input)
* addTimeAsState (Experimental feature: this replaces each occurrence of variable time with a new introduced state $time with equation der($time) = 1.0)
* calculateStateSetsJacobians (Generates analytical jacobian for dynamic state selection sets.)
* 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)
* collapseArrayExpressions (Simplifies {x[1],x[2],x[3]} → x for arrays of whole variable references (simplifies code generation).)
* 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.)
* countOperations (Count the mathematical operations of the system.)
* cseBinary (Common Sub-expression Elimination)
* dumpComponentsGraphStr (Dumps the assignment graph used to determine strong components to format suitable for Mathematica)
* dumpDAE (dumps the DAE representation of the current transformation state)
* dumpDAEXML (dumps the DAE as xml representation of the current transformation state)
* 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.)
* extendDynamicOptimization (Move loops to constraints.)
* generateSymbolicLinearization (Generates symbolic linearization matrices A,B,C,D for linear model::math:`\dot{x} = Ax + Bu `:math:`y = Cx +Du`)
* generateSymbolicSensitivities (Generates symbolic Sensivities matrix, where der(x) is differentiated w.r.t. param.)
* inlineArrayEqn (This module expands all array equations to scalar equations.)
* inputDerivativesUsed (Checks if derivatives of inputs are need to calculate the model.)
* lateInlineFunction (Perform function inlining for function with annotation LateInline=true.)
* partlintornsystem (partitions linear torn systems.)
* recursiveTearing (inline and repeat tearing)
* reduceDynamicOptimization (Removes equations which are not needed for the calculations of cost and constraints. This module requires --postOptModules+=reduceDynamicOptimization.)
* relaxSystem (relaxation from gausian elemination)
* removeConstants (Remove all constants in the system.)
* removeEqualRHS (Detects equal function calls of the form a=f(b) and c=f(b) and substitutes them to get speed up.)
* removeSimpleEquations (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).)
* removeUnusedParameter (Strips all parameter not present in the equations from the system to get speed up for compilation of target code.)
* removeUnusedVariables (Strips all variables not present in the equations from the system to get speed up for compilation of target code.)
* reshufflePost (Reshuffles algebraic loops.)
* simplifyAllExpressions (Does simplifications on all expressions.)
* simplifyComplexFunction (Some simplifications on complex functions (complex refers to the internal data structure))
* simplifyConstraints (Rewrites nonlinear constraints into box constraints if possible. This module requires +gDynOpt.)
* simplifyLoops (Simplifies algebraic loops. This modules requires +simplifyLoops.)
* simplifyTimeIndepFuncCalls (Simplifies time independent built in function calls like pre(param) -> param, der(param) -> 0.0, change(param) -> false, edge(param) -> false.)
* simplifysemiLinear (Simplifies calls to semiLinear.)
* solveLinearSystem (solve linear system with newton step)
* solveSimpleEquations (Solves simple equations)
* symSolver (Rewrites the ode system for implicit Euler method. This module requires +symSolver.)
* symbolicJacobian (Detects the sparse pattern of the ODE system and calculates also the symbolic Jacobian if flag '--generateSymbolicJacobian' is enabled.)
* tearingSystem (For method selection use flag tearingMethod.)
* wrapFunctionCalls (This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.)

.. _omcflag-simCodeTarget:

:ref:`--simCodeTarget<omcflag-simCodeTarget>`

Sets the target language for the code generation.

String (default C). Valid options:

* None
* C
* Cpp
* omsicpp
* ExperimentalEmbeddedC
* JavaScript
* omsic
* XML
* MidC

.. _omcflag-orderConnections:

:ref:`--orderConnections<omcflag-orderConnections>`

Orders connect equations alphabetically if set.

Boolean (default ``true``).

.. _omcflag-typeinfo:

:ref:`-t, --typeinfo<omcflag-typeinfo>`

Prints out extra type information if set.

Boolean (default ``false``).

.. _omcflag-keepArrays:

:ref:`-a, --keepArrays<omcflag-keepArrays>`

Sets whether to split arrays or not.

Boolean (default ``false``).

.. _omcflag-modelicaOutput:

:ref:`-m, --modelicaOutput<omcflag-modelicaOutput>`

Enables valid modelica output for flat modelica.

Boolean (default ``false``).

.. _omcflag-silent:

:ref:`-q, --silent<omcflag-silent>`

Turns on silent mode.

Boolean (default ``false``).

.. _omcflag-corbaSessionName:

:ref:`-c, --corbaSessionName<omcflag-corbaSessionName>`

Sets the name of the corba session if -d=interactiveCorba or --interactive=corba is used.

String (default *empty*).

.. _omcflag-numProcs:

:ref:`-n, --numProcs<omcflag-numProcs>`

Sets the number of processors to use (0=default=auto).

Integer (default ``0``).

.. _omcflag-instClass:

:ref:`-i, --instClass<omcflag-instClass>`

Instantiate the class given by the fully qualified path.

String (default *empty*).

.. _omcflag-vectorizationLimit:

:ref:`-v, --vectorizationLimit<omcflag-vectorizationLimit>`

Sets the vectorization limit, arrays and matrices larger than this will not be vectorized.

Integer (default ``0``).

.. _omcflag-simulationCg:

:ref:`-s, --simulationCg<omcflag-simulationCg>`

Turns on simulation code generation.

Boolean (default ``false``).

.. _omcflag-evalAnnotationParams:

:ref:`--evalAnnotationParams<omcflag-evalAnnotationParams>`

Sets whether to evaluate parameters in annotations or not.

Boolean (default ``false``).

.. _omcflag-unitChecking:

:ref:`--unitChecking<omcflag-unitChecking>`

Enable unit checking.

Boolean (default ``false``).

.. _omcflag-generateLabeledSimCode:

:ref:`--generateLabeledSimCode<omcflag-generateLabeledSimCode>`

Turns on labeled SimCode generation for reduction algorithms.

Boolean (default ``false``).

.. _omcflag-reduceTerms:

:ref:`--reduceTerms<omcflag-reduceTerms>`

Turns on reducing terms for reduction algorithms.

Boolean (default ``false``).

.. _omcflag-reductionMethod:

:ref:`--reductionMethod<omcflag-reductionMethod>`

Sets the reduction method to be used.

String (default deletion). Valid options:

* deletion
* substitution
* linearization

.. _omcflag-demoMode:

:ref:`--demoMode<omcflag-demoMode>`

Disable Warning/Error Massages.

Boolean (default ``false``).

.. _omcflag-locale:

:ref:`--locale<omcflag-locale>`

Override the locale from the environment.

String (default *empty*).

.. _omcflag-defaultOCLDevice:

:ref:`-o, --defaultOCLDevice<omcflag-defaultOCLDevice>`

Sets the default OpenCL device to be used for parallel execution.

Integer (default ``0``).

.. _omcflag-maxTraversals:

:ref:`--maxTraversals<omcflag-maxTraversals>`

Maximal traversals to find simple equations in the acausal system.

Integer (default ``2``).

.. _omcflag-dumpTarget:

:ref:`--dumpTarget<omcflag-dumpTarget>`

Redirect the dump to file. If the file ends with .html HTML code is generated.

String (default *empty*).

.. _omcflag-delayBreakLoop:

:ref:`--delayBreakLoop<omcflag-delayBreakLoop>`

Enables (very) experimental code to break algebraic loops using the delay() operator. Probably messes with initialization.

Boolean (default ``true``).

.. _omcflag-tearingMethod:

:ref:`--tearingMethod<omcflag-tearingMethod>`

Sets the tearing method to use. Select no tearing or choose tearing method.

String (default cellier). Valid options:

* noTearing (Deprecated, use minimalTearing.)
* minimalTearing (Minimal tearing method to only tear discrete variables.)
* omcTearing (Tearing method developed by TU Dresden: Frenkel, Schubert.)
* cellier (Tearing based on Celliers method, revised by FH Bielefeld: Täuber, Patrick)

.. _omcflag-tearingHeuristic:

:ref:`--tearingHeuristic<omcflag-tearingHeuristic>`

Sets the tearing heuristic to use for Cellier-tearing.

String (default MC3). Valid options:

* MC1 (Original cellier with consideration of impossible assignments and discrete Vars.)
* MC2 (Modified cellier, drop first step.)
* MC11 (Modified MC1, new last step 'count impossible assignments'.)
* MC21 (Modified MC2, new last step 'count impossible assignments'.)
* MC12 (Modified MC1, step 'count impossible assignments' before last step.)
* MC22 (Modified MC2, step 'count impossible assignments' before last step.)
* MC13 (Modified MC1, build sum of impossible assignment and causalizable equations, choose var with biggest sum.)
* MC23 (Modified MC2, build sum of impossible assignment and causalizable equations, choose var with biggest sum.)
* MC231 (Modified MC23, Two rounds, choose better potentials-set.)
* MC3 (Modified cellier, build sum of impossible assignment and causalizable equations for all vars, choose var with biggest sum.)
* MC4 (Modified cellier, use all heuristics, choose var that occurs most in potential sets)

.. _omcflag-scalarizeMinMax:

:ref:`--scalarizeMinMax<omcflag-scalarizeMinMax>`

Scalarizes the builtin min/max reduction operators if true.

Boolean (default ``false``).

.. _omcflag-strict:

:ref:`--strict<omcflag-strict>`

Enables stricter enforcement of Modelica language rules.

Boolean (default ``false``).

.. _omcflag-scalarizeBindings:

:ref:`--scalarizeBindings<omcflag-scalarizeBindings>`

Always scalarizes bindings if set.

Boolean (default ``false``).

.. _omcflag-corbaObjectReferenceFilePath:

:ref:`--corbaObjectReferenceFilePath<omcflag-corbaObjectReferenceFilePath>`

Sets the path for corba object reference file if -d=interactiveCorba is used.

String (default *empty*).

.. _omcflag-hpcomScheduler:

:ref:`--hpcomScheduler<omcflag-hpcomScheduler>`

Sets the scheduler for task graph scheduling (list | listr | level | levelfix | ext | metis | mcp | taskdep | tds | bls | rand | none). Default: level.

String (default level).

.. _omcflag-hpcomCode:

:ref:`--hpcomCode<omcflag-hpcomCode>`

Sets the code-type produced by hpcom (openmp | pthreads | pthreads_spin | tbb | mpi). Default: openmp.

String (default openmp).

.. _omcflag-rewriteRulesFile:

:ref:`--rewriteRulesFile<omcflag-rewriteRulesFile>`

Activates user given rewrite rules for Absyn expressions. The rules are read from the given file and are of the form rewrite(fromExp, toExp);

String (default *empty*).

.. _omcflag-replaceHomotopy:

:ref:`--replaceHomotopy<omcflag-replaceHomotopy>`

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.

String (default none). Valid options:

* none (Default, do not replace homotopy.)
* actual (Replace homotopy(actual, simplified) with actual.)
* simplified (Replace homotopy(actual, simplified) with simplified.)

.. _omcflag-generateSymbolicJacobian:

:ref:`--generateSymbolicJacobian<omcflag-generateSymbolicJacobian>`

Generates symbolic Jacobian matrix, where der(x) is differentiated w.r.t. x. This matrix can be used by dassl or ida solver with simulation flag '-jacobian'.

Boolean (default ``false``).

.. _omcflag-generateSymbolicLinearization:

:ref:`--generateSymbolicLinearization<omcflag-generateSymbolicLinearization>`

Generates symbolic linearization matrices A,B,C,D for linear model:
		:math:`\dot x = Ax + Bu`
		:math:`y = Cx +Du`

Boolean (default ``false``).

.. _omcflag-intEnumConversion:

:ref:`--intEnumConversion<omcflag-intEnumConversion>`

Allow Integer to enumeration conversion.

Boolean (default ``false``).

.. _omcflag-profiling:

:ref:`--profiling<omcflag-profiling>`

Sets the profiling level to use. Profiled equations and functions record execution time and count for each time step taken by the integrator.

String (default none). Valid options:

* none (Generate code without profiling)
* blocks (Generate code for profiling function calls as well as linear and non-linear systems of equations)
* blocks+html (Like blocks, but also run xsltproc and gnuplot to generate an html report)
* all (Generate code for profiling of all functions and equations)
* all_perf (Generate code for profiling of all functions and equations with additional performance data using the papi-interface (cpp-runtime))
* all_stat (Generate code for profiling of all functions and equations with additional statistics (cpp-runtime))

.. _omcflag-reshuffle:

:ref:`--reshuffle<omcflag-reshuffle>`

sets tolerance of reshuffling algorithm: 1: conservative, 2: more tolerant, 3 resolve all

Integer (default ``1``).

.. _omcflag-gDynOpt:

:ref:`--gDynOpt<omcflag-gDynOpt>`

Generate dynamic optimization problem based on annotation approach.

Boolean (default ``false``).

.. _omcflag-maxSizeSolveLinearSystem:

:ref:`--maxSizeSolveLinearSystem<omcflag-maxSizeSolveLinearSystem>`

Max size for solveLinearSystem.

Integer (default ``0``).

.. _omcflag-cppFlags:

:ref:`--cppFlags<omcflag-cppFlags>`

Sets extra flags for compilation with the C++ compiler (e.g. +cppFlags=-O3,-Wall)

String list (default ).

.. _omcflag-removeSimpleEquations:

:ref:`--removeSimpleEquations<omcflag-removeSimpleEquations>`

Specifies method that removes simple equations.

String (default default). Valid options:

* none (Disables module)
* default (Performs alias elimination and removes constant variables. Default case uses in preOpt phase the fastAcausal and in postOpt phase the causal implementation.)
* causal (Performs alias elimination and removes constant variables. Causal implementation.)
* fastAcausal (Performs alias elimination and removes constant variables. fastImplementation fastAcausal.)
* allAcausal (Performs alias elimination and removes constant variables. Implementation allAcausal.)
* new (New implementation (experimental))

.. _omcflag-dynamicTearing:

:ref:`--dynamicTearing<omcflag-dynamicTearing>`

Activates dynamic tearing (TearingSet can be changed automatically during runtime, strict set vs. casual set.)

String (default false). Valid options:

* false (No dynamic tearing.)
* true (Dynamic tearing for linear and nonlinear systems.)
* linear (Dynamic tearing only for linear systems.)
* nonlinear (Dynamic tearing only for nonlinear systems.)

.. _omcflag-symSolver:

:ref:`--symSolver<omcflag-symSolver>`

Activates symbolic implicit solver (original system is not changed).

String (default  none). Valid options:

* none
* impEuler
* expEuler

.. _omcflag-loop2con:

:ref:`--loop2con<omcflag-loop2con>`

Specifies method that transform loops in constraints. hint: using initial guess from file!

String (default none). Valid options:

* none (Disables module)
* lin (linear loops --> constraints)
* noLin (no linear loops --> constraints)
* all (loops --> constraints)

.. _omcflag-forceTearing:

:ref:`--forceTearing<omcflag-forceTearing>`

Use tearing set even if it is not smaller than the original component.

Boolean (default ``false``).

.. _omcflag-simplifyLoops:

:ref:`--simplifyLoops<omcflag-simplifyLoops>`

Simplify algebraic loops.

Integer (default ``0``). Valid options:

* 0 (do nothing)
* 1 (special modification of residual expressions)
* 2 (special modification of residual expressions with helper variables)

.. _omcflag-recursiveTearing:

:ref:`--recursiveTearing<omcflag-recursiveTearing>`

Inline and repeat tearing.

Integer (default ``0``). Valid options:

* 0 (do nothing)
* 1 (linear tearing set of size 1)
* 2 (linear tearing)

.. _omcflag-flowThreshold:

:ref:`--flowThreshold<omcflag-flowThreshold>`

Sets the minium threshold for stream flow rates

Real (default ``1e-7``).

.. _omcflag-matrixFormat:

:ref:`--matrixFormat<omcflag-matrixFormat>`

Sets the matrix format type in cpp runtime which should be used (dense | sparse ). Default: dense.

String (default dense).

.. _omcflag-partlintorn:

:ref:`--partlintorn<omcflag-partlintorn>`

Sets the limit for partitionin of linear torn systems.

Integer (default ``0``).

.. _omcflag-initOptModules:

:ref:`--initOptModules<omcflag-initOptModules>`

Sets the initialization optimization modules to use in the back end. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default simplifyComplexFunction,tearingSystem,solveSimpleEquations,calculateStrongComponentJacobians,simplifyAllExpressions,collapseArrayExpressions). Valid options:

* 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)
* collapseArrayExpressions (Simplifies {x[1],x[2],x[3]} → x for arrays of whole variable references (simplifies code generation).)
* inlineArrayEqn (This module expands all array equations to scalar equations.)
* 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.)
* extendDynamicOptimization (Move loops to constraints.)
* generateHomotopyComponents (Finds the parts of the DAE that have to be handled by the homotopy solver and creates a strong component out of it.)
* inlineHomotopy (Experimental: Inlines the homotopy expression to allow symbolic simplifications.)
* inputDerivativesUsed (Checks if derivatives of inputs are need to calculate the model.)
* recursiveTearing (inline and repeat tearing)
* reduceDynamicOptimization (Removes equations which are not needed for the calculations of cost and constraints. This module requires --postOptModules+=reduceDynamicOptimization.)
* replaceHomotopyWithSimplified (Replaces the homotopy expression homotopy(actual, simplified) with the simplified part.)
* simplifyAllExpressions (Does simplifications on all expressions.)
* simplifyComplexFunction (Some simplifications on complex functions (complex refers to the internal data structure))
* simplifyConstraints (Rewrites nonlinear constraints into box constraints if possible. This module requires +gDynOpt.)
* simplifyLoops (Simplifies algebraic loops. This modules requires +simplifyLoops.)
* solveSimpleEquations (Solves simple equations)
* tearingSystem (For method selection use flag tearingMethod.)
* wrapFunctionCalls (This module introduces variables for each function call and substitutes all these calls with the newly introduced variables.)

.. _omcflag-maxMixedDeterminedIndex:

:ref:`--maxMixedDeterminedIndex<omcflag-maxMixedDeterminedIndex>`

Sets the maximum mixed-determined index that is handled by the initialization.

Integer (default ``10``).

.. _omcflag-useLocalDirection:

:ref:`--useLocalDirection<omcflag-useLocalDirection>`

Keeps the input/output prefix for all variables in the flat model, not only top-level ones.

Boolean (default ``false``).

.. _omcflag-defaultOptModulesOrdering:

:ref:`--defaultOptModulesOrdering<omcflag-defaultOptModulesOrdering>`

If this is activated, then the specified pre-/post-/init-optimization modules will be rearranged to the recommended ordering.

Boolean (default ``true``).

.. _omcflag-preOptModules+:

:ref:`--preOptModules+<omcflag-preOptModules+>`

Enables additional pre-optimization modules, e.g. --preOptModules+=module1,module2 would additionally enable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-preOptModules-:

:ref:`--preOptModules-<omcflag-preOptModules->`

Disables a list of pre-optimization modules, e.g. --preOptModules-=module1,module2 would disable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-postOptModules+:

:ref:`--postOptModules+<omcflag-postOptModules+>`

Enables additional post-optimization modules, e.g. --postOptModules+=module1,module2 would additionally enable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-postOptModules-:

:ref:`--postOptModules-<omcflag-postOptModules->`

Disables a list of post-optimization modules, e.g. --postOptModules-=module1,module2 would disable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-initOptModules+:

:ref:`--initOptModules+<omcflag-initOptModules+>`

Enables additional init-optimization modules, e.g. --initOptModules+=module1,module2 would additionally enable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-initOptModules-:

:ref:`--initOptModules-<omcflag-initOptModules->`

Disables a list of init-optimization modules, e.g. --initOptModules-=module1,module2 would disable module1 and module2. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default *empty*).

.. _omcflag-instCacheSize:

:ref:`--instCacheSize<omcflag-instCacheSize>`

Sets the size of the internal hash table used for instantiation caching.

Integer (default ``25343``).

.. _omcflag-maxSizeLinearTearing:

:ref:`--maxSizeLinearTearing<omcflag-maxSizeLinearTearing>`

Sets the maximum system size for tearing of linear systems (default 200).

Integer (default ``200``).

.. _omcflag-maxSizeNonlinearTearing:

:ref:`--maxSizeNonlinearTearing<omcflag-maxSizeNonlinearTearing>`

Sets the maximum system size for tearing of nonlinear systems (default 10000).

Integer (default ``10000``).

.. _omcflag-noTearingForComponent:

:ref:`--noTearingForComponent<omcflag-noTearingForComponent>`

Deactivates tearing for the specified components.
Use '-d=tearingdump' to find out the relevant indexes.

Unknown default valueFlags.FlagData.INT_LIST_FLAG(data = {NIL})

.. _omcflag-daeMode:

:ref:`--daeMode<omcflag-daeMode>`

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.

Boolean (default ``false``).

.. _omcflag-inlineMethod:

:ref:`--inlineMethod<omcflag-inlineMethod>`

Sets the inline method to use.
replace : This method inlines by replacing in place all expressions. Might lead to very long expression.
append  : This method inlines by adding additional variables to the whole system. Might lead to much bigger system.

String (default  replace). Valid options:

* replace
* append

.. _omcflag-setTearingVars:

:ref:`--setTearingVars<omcflag-setTearingVars>`

Sets the tearing variables by its strong component indexes. Use '-d=tearingdump' to find out the relevant indexes.
Use following format: '--setTearingVars=(sci,n,t1,...,tn)*', with sci = strong component index, n = number of tearing variables, t1,...tn = tearing variables.
E.g.: '--setTearingVars=4,2,3,5' would select variables 3 and 5 in strong component 4.

Unknown default valueFlags.FlagData.INT_LIST_FLAG(data = {NIL})

.. _omcflag-setResidualEqns:

:ref:`--setResidualEqns<omcflag-setResidualEqns>`

Sets the residual equations by its strong component indexes. Use '-d=tearingdump' to find out the relevant indexes for the collective equations.
Use following format: '--setResidualEqns=(sci,n,r1,...,rn)*', with sci = strong component index, n = number of residual equations, r1,...rn = residual equations.
E.g.: '--setResidualEqns=4,2,3,5' would select equations 3 and 5 in strong component 4.
Only works in combination with 'setTearingVars'.

Unknown default valueFlags.FlagData.INT_LIST_FLAG(data = {NIL})

.. _omcflag-ignoreCommandLineOptionsAnnotation:

:ref:`--ignoreCommandLineOptionsAnnotation<omcflag-ignoreCommandLineOptionsAnnotation>`

Ignores the command line options specified as annotation in the class.

Boolean (default ``false``).

.. _omcflag-calculateSensitivities:

:ref:`--calculateSensitivities<omcflag-calculateSensitivities>`

Generates sensitivities variables and matrices.

Boolean (default ``false``).

.. _omcflag-alarm:

:ref:`-r, --alarm<omcflag-alarm>`

Sets the number seconds until omc timeouts and exits. Used by the testing framework to terminate infinite running processes.

Integer (default ``0``).

.. _omcflag-totalTearing:

:ref:`--totalTearing<omcflag-totalTearing>`

Activates total tearing (determination of all possible tearing sets) for the specified components.
Use '-d=tearingdump' to find out the relevant indexes.

Unknown default valueFlags.FlagData.INT_LIST_FLAG(data = {NIL})

.. _omcflag-ignoreSimulationFlagsAnnotation:

:ref:`--ignoreSimulationFlagsAnnotation<omcflag-ignoreSimulationFlagsAnnotation>`

Ignores the simulation flags specified as annotation in the class.

Boolean (default ``false``).

.. _omcflag-dynamicTearingForInitialization:

:ref:`--dynamicTearingForInitialization<omcflag-dynamicTearingForInitialization>`

Enable Dynamic Tearing also for the initialization system.

Boolean (default ``false``).

.. _omcflag-preferTVarsWithStartValue:

:ref:`--preferTVarsWithStartValue<omcflag-preferTVarsWithStartValue>`

Prefer tearing variables with start value for initialization.

Boolean (default ``true``).

.. _omcflag-equationsPerFile:

:ref:`--equationsPerFile<omcflag-equationsPerFile>`

Generate code for at most this many equations per C-file (partially implemented in the compiler).

Integer (default ``500``).

.. _omcflag-evaluateFinalParameters:

:ref:`--evaluateFinalParameters<omcflag-evaluateFinalParameters>`

Evaluates all the final parameters in addition to parameters with annotation(Evaluate=true).

Boolean (default ``false``).

.. _omcflag-evaluateProtectedParameters:

:ref:`--evaluateProtectedParameters<omcflag-evaluateProtectedParameters>`

Evaluates all the protected parameters in addition to parameters with annotation(Evaluate=true).

Boolean (default ``false``).

.. _omcflag-replaceEvaluatedParameters:

:ref:`--replaceEvaluatedParameters<omcflag-replaceEvaluatedParameters>`

Replaces all the evaluated parameters in the DAE.

Boolean (default ``true``).

.. _omcflag-condenseArrays:

:ref:`--condenseArrays<omcflag-condenseArrays>`

Sets whether array expressions containing function calls are condensed or not.

Boolean (default ``true``).

.. _omcflag-wfcAdvanced:

:ref:`--wfcAdvanced<omcflag-wfcAdvanced>`

wrapFunctionCalls ignores more then default cases, e.g. exp, sin, cos, log, (experimental flag)

Boolean (default ``false``).

.. _omcflag-tearingStrictness:

:ref:`--tearingStrictness<omcflag-tearingStrictness>`

Sets the strictness of the tearing method regarding the solvability restrictions.

String (default strict). Valid options:

* 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.)
* strict (Robust tearing rules by consideration of the partial derivative. Allows to divide by parameters that are not equal to or close to zero.)
* 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.)

.. _omcflag-interactive:

:ref:`--interactive<omcflag-interactive>`

Sets the interactive mode for omc.

String (default none). Valid options:

* none (do nothing)
* corba (Starts omc as a server listening on the Corba interface.)
* tcp (Starts omc as a server listening on the socket interface.)
* zmq (Starts omc as a ZeroMQ server listening on the socket interface.)

.. _omcflag-zeroMQFileSuffix:

:ref:`-z, --zeroMQFileSuffix<omcflag-zeroMQFileSuffix>`

Sets the file suffix for zeroMQ port file if --interactive=zmq is used.

String (default *empty*).

.. _omcflag-homotopyApproach:

:ref:`--homotopyApproach<omcflag-homotopyApproach>`

Sets the homotopy approach.

String (default equidistantGlobal). Valid options:

* equidistantLocal (Local homotopy approach with equidistant lambda steps. The homotopy parameter only effects the local strongly connected component.)
* adaptiveLocal (Local homotopy approach with adaptive lambda steps. The homotopy parameter only effects the local strongly connected component.)
* equidistantGlobal (Default, global homotopy approach with equidistant lambda steps. The homotopy parameter effects the entire initialization system.)
* adaptiveGlobal (Global homotopy approach with adaptive lambda steps. The homotopy parameter effects the entire initialization system.)

.. _omcflag-ignoreReplaceable:

:ref:`--ignoreReplaceable<omcflag-ignoreReplaceable>`

Sets whether to ignore replaceability or not when redeclaring.

Boolean (default ``false``).

.. _omcflag-postOptModulesDAE:

:ref:`--postOptModulesDAE<omcflag-postOptModulesDAE>`

Sets the optimization modules for the DAEmode in the back end. See :ref:`--help=optmodules <omcflag-optmodules-section>` for more info.

String list (default lateInlineFunction,wrapFunctionCalls,simplifysemiLinear,simplifyComplexFunction,removeConstants,simplifyTimeIndepFuncCalls,simplifyAllExpressions,findZeroCrossings,createDAEmodeBDAE,symbolicJacobianDAE,setEvaluationStage).

.. _omcflag-evalLoopLimit:

:ref:`--evalLoopLimit<omcflag-evalLoopLimit>`

The loop iteration limit used when evaluating constant function calls.

Integer (default ``100000``).

.. _omcflag-evalRecursionLimit:

:ref:`--evalRecursionLimit<omcflag-evalRecursionLimit>`

The recursion limit used when evaluating constant function calls.

Integer (default ``256``).

.. _omcflag-singleInstanceAglSolver:

:ref:`--singleInstanceAglSolver<omcflag-singleInstanceAglSolver>`

Sets to instantiate only  one algebraic loop solver all algebraic loops

Boolean (default ``false``).

.. _omcflag-showStructuralAnnotations:

:ref:`--showStructuralAnnotations<omcflag-showStructuralAnnotations>`

Show annotations affecting the solution process in the flattened code.

Boolean (default ``false``).

.. _omcflag-initialStateSelection:

:ref:`--initialStateSelection<omcflag-initialStateSelection>`

Activates the state selection inside initialization to avoid singularities.

Boolean (default ``false``).

.. _omcflag-linearizationDumpLanguage:

:ref:`--linearizationDumpLanguage<omcflag-linearizationDumpLanguage>`

Sets the target language for the produced code of linearization. Only works with '--generateSymbolicLinearization' and 'linearize(modelName)'.

String (default modelica). Valid options:

* modelica
* matlab
* julia
* python

.. _omcflag-noASSC:

:ref:`--noASSC<omcflag-noASSC>`

Disables analytical to structural singularity conversion.

Boolean (default ``false``).

.. _omcflag-fullASSC:

:ref:`--fullASSC<omcflag-fullASSC>`

Enables full equation replacement for BLT transformation from the ASSC algorithm.

Boolean (default ``false``).

.. _omcflag-realASSC:

:ref:`--realASSC<omcflag-realASSC>`

Enables the ASSC algorithm to evaluate real valued coefficients (usually only integers).

Boolean (default ``false``).

.. _omcflag-initASSC:

:ref:`--initASSC<omcflag-initASSC>`

Enables the ASSC algorithm for initialization.

Boolean (default ``false``).

.. _omcflag-maxSizeASSC:

:ref:`--maxSizeASSC<omcflag-maxSizeASSC>`

Sets the maximum system size for the analytical to structural conversion algorithm (default 200).

Integer (default ``200``).

.. _omcflag-baseModelica:

:ref:`-f, --baseModelica<omcflag-baseModelica>`

Outputs experimental Base Modelica.

Boolean (default ``false``).

.. _omcflag-fmiFilter:

:ref:`--fmiFilter<omcflag-fmiFilter>`

Specifies which model variables are exposed by the modelDescription.xml

String (default  protected). Valid options:

* none (All variables are exposed, even variables introduced by the symbolic transformations. This is mainly for debugging purposes.)
* 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.)
* protected (All public model variables are exposed. Internal and protected variables are filtered out, with small exceptions, e.g. for state sets.)
* blackBox (Only the interface is exposed. All other variables are hidden or exposed with concealed names.)

.. _omcflag-fmiSources:

:ref:`--fmiSources<omcflag-fmiSources>`

Defines if FMUs will be exported with sources or not. --fmiFilter=blackBox might override this, because black box FMUs do never contain their source code.

Boolean (default ``true``).

.. _omcflag-fmiFlags:

:ref:`--fmiFlags<omcflag-fmiFlags>`

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.

String list (default *empty*).

.. _omcflag-fmuCMakeBuild:

:ref:`--fmuCMakeBuild<omcflag-fmuCMakeBuild>`

Configured and build FMU with CMake if true.

Boolean (default ``true``).

.. _omcflag-newBackend:

:ref:`--newBackend<omcflag-newBackend>`

Activates experimental new backend for better array handling. This also activates the new frontend. [WIP]

Boolean (default ``false``).

.. _omcflag-parmodauto:

:ref:`--parmodauto<omcflag-parmodauto>`

Experimental: Enable parallelization of independent systems of equations in the translated model. Only works on Linux systems.

Boolean (default ``false``).

.. _omcflag-interactivePort:

:ref:`--interactivePort<omcflag-interactivePort>`

Sets the port used by the interactive server.

Integer (default ``0``).

.. _omcflag-allowNonStandardModelica:

:ref:`--allowNonStandardModelica<omcflag-allowNonStandardModelica>`

Flags to allow non-standard Modelica.

String list (default *empty*). Valid options:

* nonStdMultipleExternalDeclarations (Allow several external declarations in functions.See: https://specification.modelica.org/maint/3.5/functions.html#function-as-a-specialized-class)
* nonStdEnumerationAsIntegers (Allow enumeration as integer without casting via Integer(Enum).See: https://specification.modelica.org/maint/3.5/class-predefined-types-and-declarations.html#type-conversion-of-enumeration-values-to-string-or-integer)
* nonStdIntegersAsEnumeration (Allow integer as enumeration without casting via Enum(Integer).See: https://specification.modelica.org/maint/3.5/class-predefined-types-and-declarations.html#type-conversion-of-integer-to-enumeration-values)
* nonStdDifferentCaseFileVsClassName (Allow directory or file with different case in the name than the contained class name.See: https://specification.modelica.org/maint/3.5/packages.html#mapping-package-class-structures-to-a-hierarchical-file-system)
* nonStdTopLevelOuter (Allow top level outer.See: https://specification.modelica.org/maint/3.6/scoping-name-lookup-and-flattening.html#S4.p1)
* protectedAccess (Allow access of protected elements)
* reinitInAlgorithms (Allow reinit in algorithm sections)
* unbalancedModel (Allow models to be locally unbalanced and to have unbalanced connectors)

.. _omcflag-exportClocksInModelDescription:

:ref:`--exportClocksInModelDescription<omcflag-exportClocksInModelDescription>`

exports clocks in modeldescription.xml for fmus, The default is false.

Boolean (default ``false``).

.. _omcflag-linkType:

:ref:`--linkType<omcflag-linkType>`

Sets the link type for the simulation executable.
dynamic: libraries are dynamically linked; the executable is built very fast but is not portable because of DLL dependencies.
static: libraries are statically linked; the executable is built more slowly but it is portable and dependency-free.


String (default  dynamic). Valid options:

* dynamic
* static

.. _omcflag-tearingAlwaysDer:

:ref:`--tearingAlwaysDer<omcflag-tearingAlwaysDer>`

Always choose state derivatives as iteration variables in strong components.

Boolean (default ``false``).

.. _omcflag-dumpFlatModel:

:ref:`--dumpFlatModel<omcflag-dumpFlatModel>`

Dumps the flat model at the given stages of the frontend.

String list (default all). Valid options:

* flatten (After flattening but before connection handling.)
* connections (After connection handling.)
* eval (After evaluating constants.)
* simplify (After model simplification.)
* scalarize (After scalarizing arrays.)

.. _omcflag-simulation:

:ref:`-u, --simulation<omcflag-simulation>`

Simulates the last model in the given Modelica file.

Boolean (default ``false``).

.. _omcflag-obfuscate:

:ref:`--obfuscate<omcflag-obfuscate>`

Obfuscates identifiers in the simulation model

String (default none). Valid options:

* none (No obfuscation.)
* encrypted (Obfuscates protected variables in encrypted models)
* protected (Obfuscates protected variables in all models.)
* full (Obfuscates everything.)

.. _omcflag-fmuRuntimeDepends:

:ref:`--fmuRuntimeDepends<omcflag-fmuRuntimeDepends>`

Defines if runtime library dependencies are included in the FMU. Only used when compiler flag fmuCMakeBuild=true.

String (default default). Valid options:

* default (Depending on CMake version. If CMake version >= 3.21 use  "modelica", otherwise use "none")
* none (No runtime library dependencies are copied into the FMU.)
* modelica (All modelica runtime library dependencies are copied into the FMU.System librarys located in '/lib*', '/usr/lib*' and '/usr/local/lib*' are excluded.Needs --fmuCMakeBuild=true and CMake version >= 3.21.)
* all (All runtime library dependencies are copied into the FMU.System librarys are copied as well.Needs --fmuCMakeBuild=true and CMake version >= 3.21.)

.. _omcflag-frontendInline:

:ref:`--frontendInline<omcflag-frontendInline>`

Enables inlining of functions in the frontend.

Boolean (default ``false``).

.. _omcflag-nonStdExposeLocalIOs:

:ref:`--nonStdExposeLocalIOs<omcflag-nonStdExposeLocalIOs>`

Keeps input/output prefixes for unconnected input/output connectors at requested levels, provided they are public, 0 meaning top-level (standard Modelica), 1 inputs/outputs of top-level components, >1 going deeper. This flag is particularly useful for FMI export. It extends the Modelica standard when exposing local inputs.

Integer (default ``0``).


.. _omcflag-debug-section:

Debug flags
-----------

The debug flag takes a comma-separated list of flags which are used by the
compiler for debugging or experimental purposes.
Flags prefixed with "-" or "no" will be disabled.
The available flags are (+ are enabled by default, - are disabled):


.. _omcflag-debug-Cache:

:ref:`Cache <omcflag-debug-Cache>` (default: on)
  Turns off the instantiation cache.

.. _omcflag-debug-LSanalyticJacobian:

:ref:`LSanalyticJacobian <omcflag-debug-LSanalyticJacobian>` (default: off)
  Enables analytical jacobian for linear strong components. Defaults to false

.. _omcflag-debug-NLSanalyticJacobian:

:ref:`NLSanalyticJacobian <omcflag-debug-NLSanalyticJacobian>` (default: on)
  Enables analytical jacobian for non-linear strong components without user-defined function calls, for that see forceNLSanalyticJacobian

.. _omcflag-debug-acceptTooManyFields:

:ref:`acceptTooManyFields <omcflag-debug-acceptTooManyFields>` (default: off)
  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.

.. _omcflag-debug-aliasConflicts:

:ref:`aliasConflicts <omcflag-debug-aliasConflicts>` (default: off)
  Dumps alias sets with different start or nominal values.

.. _omcflag-debug-arrayConnect:

:ref:`arrayConnect <omcflag-debug-arrayConnect>` (default: off)
  Use experimental array connection handler.

.. _omcflag-debug-backendKeepEnv:

:ref:`backendKeepEnv <omcflag-debug-backendKeepEnv>` (default: on)
  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).

.. _omcflag-debug-backendReduceDAE:

:ref:`backendReduceDAE <omcflag-debug-backendReduceDAE>` (default: off)
  Prints all Reduce DAE debug information.

.. _omcflag-debug-backenddaeinfo:

:ref:`backenddaeinfo <omcflag-debug-backenddaeinfo>` (default: off)
  Enables dumping of back-end information about system (Number of equations before back-end,...).

.. _omcflag-debug-bltdump:

:ref:`bltdump <omcflag-debug-bltdump>` (default: off)
  Dumps information from index reduction.

.. _omcflag-debug-bltmatrixdump:

:ref:`bltmatrixdump <omcflag-debug-bltmatrixdump>` (default: off)
  Dumps the blt matrix in html file. IE seems to be very good in displaying large matrices.

.. _omcflag-debug-buildExternalLibs:

:ref:`buildExternalLibs <omcflag-debug-buildExternalLibs>` (default: on)
  Use the autotools project in the Resources folder of the library to build missing external libraries.

.. _omcflag-debug-ceval:

:ref:`ceval <omcflag-debug-ceval>` (default: off)
  Prints extra information from Ceval.

.. _omcflag-debug-cgraph:

:ref:`cgraph <omcflag-debug-cgraph>` (default: off)
  Prints out connection graph information.

.. _omcflag-debug-cgraphGraphVizFile:

:ref:`cgraphGraphVizFile <omcflag-debug-cgraphGraphVizFile>` (default: off)
  Generates a graphviz file of the connection graph.

.. _omcflag-debug-cgraphGraphVizShow:

:ref:`cgraphGraphVizShow <omcflag-debug-cgraphGraphVizShow>` (default: off)
  Displays the connection graph with the GraphViz lefty tool.

.. _omcflag-debug-checkASUB:

:ref:`checkASUB <omcflag-debug-checkASUB>` (default: off)
  Prints out a warning if an ASUB is created from a CREF expression.

.. _omcflag-debug-checkBackendDae:

:ref:`checkBackendDae <omcflag-debug-checkBackendDae>` (default: off)
  Do some simple analyses on the datastructure from the frontend to check if it is consistent.

.. _omcflag-debug-checkDAECrefType:

:ref:`checkDAECrefType <omcflag-debug-checkDAECrefType>` (default: off)
  Enables extra type checking for cref expressions.

.. _omcflag-debug-checkSimplify:

:ref:`checkSimplify <omcflag-debug-checkSimplify>` (default: off)
  Enables checks for expression simplification and prints a notification whenever an undesirable transformation has been performed.

.. _omcflag-debug-combineSubscripts:

:ref:`combineSubscripts <omcflag-debug-combineSubscripts>` (default: off)
  Move all subscripts to the end of component references.

.. _omcflag-debug-constjac:

:ref:`constjac <omcflag-debug-constjac>` (default: off)
  solves linear systems with constant Jacobian and variable b-Vector symbolically

.. _omcflag-debug-countOperations:

:ref:`countOperations <omcflag-debug-countOperations>` (default: off)
  Count operations.

.. _omcflag-debug-daedumpgraphv:

:ref:`daedumpgraphv <omcflag-debug-daedumpgraphv>` (default: off)
  Dumps the DAE in graphviz format.

.. _omcflag-debug-dataReconciliation:

:ref:`dataReconciliation <omcflag-debug-dataReconciliation>` (default: off)
  Dumps all the dataReconciliation extraction algorithm procedure

.. _omcflag-debug-debugAlgebraicLoopsJacobian:

:ref:`debugAlgebraicLoopsJacobian <omcflag-debug-debugAlgebraicLoopsJacobian>` (default: off)
  Dumps debug output while creating symbolic jacobians for non-linear systems.

.. _omcflag-debug-debugAlias:

:ref:`debugAlias <omcflag-debug-debugAlias>` (default: off)
  Dumps some information about the process of removeSimpleEquations.

.. _omcflag-debug-debugDAEmode:

:ref:`debugDAEmode <omcflag-debug-debugDAEmode>` (default: off)
  Dump debug output for the DAEmode.

.. _omcflag-debug-debugDifferentiation:

:ref:`debugDifferentiation <omcflag-debug-debugDifferentiation>` (default: off)
  Dumps debug output for the differentiation process.

.. _omcflag-debug-debugDifferentiationVerbose:

:ref:`debugDifferentiationVerbose <omcflag-debug-debugDifferentiationVerbose>` (default: off)
  Dumps verbose debug output for the differentiation process.

.. _omcflag-debug-disableColoring:

:ref:`disableColoring <omcflag-debug-disableColoring>` (default: off)
  Disables coloring algorithm while spasity detection.

.. _omcflag-debug-disableDirectionalDerivatives:

:ref:`disableDirectionalDerivatives <omcflag-debug-disableDirectionalDerivatives>` (default: on)
  For FMI 2.0 only dependecy analysis will be perform.

.. _omcflag-debug-disableFMIDependency:

:ref:`disableFMIDependency <omcflag-debug-disableFMIDependency>` (default: off)
  Disables the dependency analysis and generation for FMI 2.0.

.. _omcflag-debug-disableJacsforSCC:

:ref:`disableJacsforSCC <omcflag-debug-disableJacsforSCC>` (default: off)
  Disables calculation of jacobians to detect if a SCC is linear or non-linear. By disabling all SCC will handled like non-linear.

.. _omcflag-debug-disableRecordConstructorOutput:

:ref:`disableRecordConstructorOutput <omcflag-debug-disableRecordConstructorOutput>` (default: off)
  Disables output of record constructors in the flat code.

.. _omcflag-debug-disableSingleFlowEq:

:ref:`disableSingleFlowEq <omcflag-debug-disableSingleFlowEq>` (default: off)
  Disables the generation of single flow equations.

.. _omcflag-debug-disableStartCalc:

:ref:`disableStartCalc <omcflag-debug-disableStartCalc>` (default: off)
  Deactivates the pre-calculation of start values during compile-time.

.. _omcflag-debug-disableWindowsPathCheckWarning:

:ref:`disableWindowsPathCheckWarning <omcflag-debug-disableWindowsPathCheckWarning>` (default: off)
  Disables warnings on Windows if OPENMODELICAHOME/MinGW is missing.

.. _omcflag-debug-discreteinfo:

:ref:`discreteinfo <omcflag-debug-discreteinfo>` (default: off)
  Enables dumping of discrete variables. Extends -d=backenddaeinfo.

.. _omcflag-debug-dummyselect:

:ref:`dummyselect <omcflag-debug-dummyselect>` (default: off)
  Dumps information from dummy state selection heuristic.

.. _omcflag-debug-dump:

:ref:`dump <omcflag-debug-dump>` (default: off)
  Dumps the absyn representation of a program.

.. _omcflag-debug-dumpASSC:

:ref:`dumpASSC <omcflag-debug-dumpASSC>` (default: off)
  Dumps the conversion process of analytical to structural singularities.

.. _omcflag-debug-dumpBackendClocks:

:ref:`dumpBackendClocks <omcflag-debug-dumpBackendClocks>` (default: off)
  Dumps times for each backend module (only new backend).

.. _omcflag-debug-dumpBackendInline:

:ref:`dumpBackendInline <omcflag-debug-dumpBackendInline>` (default: off)
  Dumps debug output while inline function.

.. _omcflag-debug-dumpBackendInlineVerbose:

:ref:`dumpBackendInlineVerbose <omcflag-debug-dumpBackendInlineVerbose>` (default: off)
  Dumps debug output while inline function.

.. _omcflag-debug-dumpBindings:

:ref:`dumpBindings <omcflag-debug-dumpBindings>` (default: off)
  Dumps information about the equations created from bindings.

.. _omcflag-debug-dumpCSE:

:ref:`dumpCSE <omcflag-debug-dumpCSE>` (default: off)
  Additional output for CSE module.

.. _omcflag-debug-dumpCSE_verbose:

:ref:`dumpCSE_verbose <omcflag-debug-dumpCSE_verbose>` (default: off)
  Additional output for CSE module.

.. _omcflag-debug-dumpConstrepl:

:ref:`dumpConstrepl <omcflag-debug-dumpConstrepl>` (default: off)
  Dump the found replacements for constants.

.. _omcflag-debug-dumpConversionRules:

:ref:`dumpConversionRules <omcflag-debug-dumpConversionRules>` (default: off)
  Dumps the rules when converting a package using a conversion script.

.. _omcflag-debug-dumpEArepl:

:ref:`dumpEArepl <omcflag-debug-dumpEArepl>` (default: off)
  Dump the found replacements for evaluate annotations (evaluate=true) parameters.

.. _omcflag-debug-dumpEncapsulateConditions:

:ref:`dumpEncapsulateConditions <omcflag-debug-dumpEncapsulateConditions>` (default: off)
  Dumps the results of the preOptModule encapsulateWhenConditions.

.. _omcflag-debug-dumpEqInUC:

:ref:`dumpEqInUC <omcflag-debug-dumpEqInUC>` (default: off)
  Dumps all equations handled by the unit checker.

.. _omcflag-debug-dumpEqUCStruct:

:ref:`dumpEqUCStruct <omcflag-debug-dumpEqUCStruct>` (default: off)
  Dumps all the equations handled by the unit checker as tree-structure.

.. _omcflag-debug-dumpEvents:

:ref:`dumpEvents <omcflag-debug-dumpEvents>` (default: off)
  Dumps information about the detected event functions.

.. _omcflag-debug-dumpExcludedSymJacExps:

:ref:`dumpExcludedSymJacExps <omcflag-debug-dumpExcludedSymJacExps>` (default: off)
  This flags dumps all expression that are excluded from differentiation of a symbolic Jacobian.

.. _omcflag-debug-dumpFPrepl:

:ref:`dumpFPrepl <omcflag-debug-dumpFPrepl>` (default: off)
  Dump the found replacements for final parameters.

.. _omcflag-debug-dumpFunctions:

:ref:`dumpFunctions <omcflag-debug-dumpFunctions>` (default: off)
  Add functions to backend dumps.

.. _omcflag-debug-dumpHomotopy:

:ref:`dumpHomotopy <omcflag-debug-dumpHomotopy>` (default: off)
  Dumps the results of the postOptModule optimizeHomotopyCalls.

.. _omcflag-debug-dumpInlineSolver:

:ref:`dumpInlineSolver <omcflag-debug-dumpInlineSolver>` (default: off)
  Dumps the inline solver equation system.

.. _omcflag-debug-dumpJL:

:ref:`dumpJL <omcflag-debug-dumpJL>` (default: off)
  Dumps the absyn representation of a program as a Julia representation

.. _omcflag-debug-dumpLoops:

:ref:`dumpLoops <omcflag-debug-dumpLoops>` (default: off)
  Dumps loop equation.

.. _omcflag-debug-dumpLoopsVerbose:

:ref:`dumpLoopsVerbose <omcflag-debug-dumpLoopsVerbose>` (default: off)
  Dumps loop equation and enhanced adjacency matrix.

.. _omcflag-debug-dumpPPrepl:

:ref:`dumpPPrepl <omcflag-debug-dumpPPrepl>` (default: off)
  Dump the found replacements for protected parameters.

.. _omcflag-debug-dumpParamrepl:

:ref:`dumpParamrepl <omcflag-debug-dumpParamrepl>` (default: off)
  Dump the found replacements for remove parameters.

.. _omcflag-debug-dumpRecursiveTearing:

:ref:`dumpRecursiveTearing <omcflag-debug-dumpRecursiveTearing>` (default: off)
  Dump between steps of recursiveTearing

.. _omcflag-debug-dumpSCCGraphML:

:ref:`dumpSCCGraphML <omcflag-debug-dumpSCCGraphML>` (default: off)
  Dumps graphml files with the strongly connected components.

.. _omcflag-debug-dumpSetBasedGraphs:

:ref:`dumpSetBasedGraphs <omcflag-debug-dumpSetBasedGraphs>` (default: off)
  Dumps information about set based graphs for efficient array handling (only new frontend and new backend).

.. _omcflag-debug-dumpSimCode:

:ref:`dumpSimCode <omcflag-debug-dumpSimCode>` (default: off)
  Dumps the simCode model used for code generation.

.. _omcflag-debug-dumpSimplify:

:ref:`dumpSimplify <omcflag-debug-dumpSimplify>` (default: off)
  Dumps expressions before and after simplification.

.. _omcflag-debug-dumpSimplifyLoops:

:ref:`dumpSimplifyLoops <omcflag-debug-dumpSimplifyLoops>` (default: off)
  Dump between steps of simplifyLoops

.. _omcflag-debug-dumpSlice:

:ref:`dumpSlice <omcflag-debug-dumpSlice>` (default: off)
  Dumps information about the slicing process (pseudo-array causalization).

.. _omcflag-debug-dumpSortEqnsAndVars:

:ref:`dumpSortEqnsAndVars <omcflag-debug-dumpSortEqnsAndVars>` (default: off)
  Dumps debug output for the modules sortEqnsVars.

.. _omcflag-debug-dumpSorting:

:ref:`dumpSorting <omcflag-debug-dumpSorting>` (default: off)
  Dumps information about the process of sorting.

.. _omcflag-debug-dumpSparsePattern:

:ref:`dumpSparsePattern <omcflag-debug-dumpSparsePattern>` (default: off)
  Dumps sparse pattern with coloring used for simulation.

.. _omcflag-debug-dumpSparsePatternVerbose:

:ref:`dumpSparsePatternVerbose <omcflag-debug-dumpSparsePatternVerbose>` (default: off)
  Dumps in verbose mode sparse pattern with coloring used for simulation.

.. _omcflag-debug-dumpSynchronous:

:ref:`dumpSynchronous <omcflag-debug-dumpSynchronous>` (default: off)
  Dumps information of the clock partitioning.

.. _omcflag-debug-dumpUnits:

:ref:`dumpUnits <omcflag-debug-dumpUnits>` (default: off)
  Dumps all the calculated units.

.. _omcflag-debug-dumpdaelow:

:ref:`dumpdaelow <omcflag-debug-dumpdaelow>` (default: off)
  Dumps the equation system at the beginning of the back end.

.. _omcflag-debug-dumpdgesv:

:ref:`dumpdgesv <omcflag-debug-dumpdgesv>` (default: off)
  Enables dumping of the information whether DGESV is used to solve linear systems.

.. _omcflag-debug-dumpeqninorder:

:ref:`dumpeqninorder <omcflag-debug-dumpeqninorder>` (default: off)
  Enables dumping of the equations in the order they are calculated.

.. _omcflag-debug-dumpindxdae:

:ref:`dumpindxdae <omcflag-debug-dumpindxdae>` (default: off)
  Dumps the equation system after index reduction and optimization.

.. _omcflag-debug-dumpinitialsystem:

:ref:`dumpinitialsystem <omcflag-debug-dumpinitialsystem>` (default: off)
  Dumps the initial equation system.

.. _omcflag-debug-dumprepl:

:ref:`dumprepl <omcflag-debug-dumprepl>` (default: off)
  Dump the found replacements for simple equation removal.

.. _omcflag-debug-dynload:

:ref:`dynload <omcflag-debug-dynload>` (default: off)
  Display debug information about dynamic loading of compiled functions.

.. _omcflag-debug-evalFuncDump:

:ref:`evalFuncDump <omcflag-debug-evalFuncDump>` (default: off)
  dumps debug information about the function evaluation

.. _omcflag-debug-evalOutputOnly:

:ref:`evalOutputOnly <omcflag-debug-evalOutputOnly>` (default: off)
  Generates equations to calculate top level outputs only.

.. _omcflag-debug-evalParameterDump:

:ref:`evalParameterDump <omcflag-debug-evalParameterDump>` (default: off)
  Dumps information for evaluating parameters.

.. _omcflag-debug-evalfunc:

:ref:`evalfunc <omcflag-debug-evalfunc>` (default: on)
  Turns on/off symbolic function evaluation.

.. _omcflag-debug-evaluateAllParameters:

:ref:`evaluateAllParameters <omcflag-debug-evaluateAllParameters>` (default: off)
  Evaluates all parameters if set.

.. _omcflag-debug-events:

:ref:`events <omcflag-debug-events>` (default: on)
  Turns on/off events handling.

.. _omcflag-debug-execHash:

:ref:`execHash <omcflag-debug-execHash>` (default: off)
  Measures the time it takes to hash all simcode variables before code generation.

.. _omcflag-debug-execstat:

:ref:`execstat <omcflag-debug-execstat>` (default: off)
  Prints out execution statistics for the compiler.

.. _omcflag-debug-execstatGCcollect:

:ref:`execstatGCcollect <omcflag-debug-execstatGCcollect>` (default: off)
  When running execstat, also perform an extra full garbage collection.

.. _omcflag-debug-experimentalReductions:

:ref:`experimentalReductions <omcflag-debug-experimentalReductions>` (default: off)
  Turns on custom reduction functions (OpenModelica extension).

.. _omcflag-debug-failtrace:

:ref:`failtrace <omcflag-debug-failtrace>` (default: off)
  Sets whether to print a failtrace or not.

.. _omcflag-debug-fmuExperimental:

:ref:`fmuExperimental <omcflag-debug-fmuExperimental>` (default: off)
  Adds features to the FMI export that are considered experimental as of now: fmi2GetSpecificDerivatives, canGetSetFMUState, canSerializeFMUstate

.. _omcflag-debug-force-fmi-attributes:

:ref:`force-fmi-attributes <omcflag-debug-force-fmi-attributes>` (default: off)
  Force to export all fmi attributes to the modelDescription.xml, including those which have default values

.. _omcflag-debug-forceNLSanalyticJacobian:

:ref:`forceNLSanalyticJacobian <omcflag-debug-forceNLSanalyticJacobian>` (default: off)
  Forces calculation analytical jacobian also for non-linear strong components with user-defined functions.

.. _omcflag-debug-frontEndUnitCheck:

:ref:`frontEndUnitCheck <omcflag-debug-frontEndUnitCheck>` (default: off)
  Checks the consistency of units in equation.

.. _omcflag-debug-gcProfiling:

:ref:`gcProfiling <omcflag-debug-gcProfiling>` (default: off)
  Prints garbage collection stats to standard output.

.. _omcflag-debug-gen:

:ref:`gen <omcflag-debug-gen>` (default: off)
  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.

.. _omcflag-debug-gendebugsymbols:

:ref:`gendebugsymbols <omcflag-debug-gendebugsymbols>` (default: off)
  Generate code with debugging symbols.

.. _omcflag-debug-generateCodeCheat:

:ref:`generateCodeCheat <omcflag-debug-generateCodeCheat>` (default: off)
  Used to generate code for the bootstrapped compiler.

.. _omcflag-debug-graphInst:

:ref:`graphInst <omcflag-debug-graphInst>` (default: off)
  Do graph based instantiation.

.. _omcflag-debug-graphInstGenGraph:

:ref:`graphInstGenGraph <omcflag-debug-graphInstGenGraph>` (default: off)
  Dumps a graph of the program. Use with -d=graphInst

.. _omcflag-debug-graphInstRunDep:

:ref:`graphInstRunDep <omcflag-debug-graphInstRunDep>` (default: off)
  Run scode dependency analysis. Use with -d=graphInst

.. _omcflag-debug-graphml:

:ref:`graphml <omcflag-debug-graphml>` (default: off)
  Dumps .graphml files for the bipartite graph after Index Reduction and a task graph for the SCCs. Can be displayed with yEd.

.. _omcflag-debug-graphviz:

:ref:`graphviz <omcflag-debug-graphviz>` (default: off)
  Dumps the absyn representation of a program in graphviz format.

.. _omcflag-debug-graphvizDump:

:ref:`graphvizDump <omcflag-debug-graphvizDump>` (default: off)
  Activates additional graphviz dumps (as .dot files). It can be used in addition to one of the following flags: {dumpdaelow|dumpinitialsystems|dumpindxdae}.

.. _omcflag-debug-hardcodedStartValues:

:ref:`hardcodedStartValues <omcflag-debug-hardcodedStartValues>` (default: off)
  Embed the start values of variables and parameters into the c++ code and do not read it from xml file.

.. _omcflag-debug-hpcom:

:ref:`hpcom <omcflag-debug-hpcom>` (default: off)
  Enables parallel calculation based on task-graphs.

.. _omcflag-debug-hpcomDump:

:ref:`hpcomDump <omcflag-debug-hpcomDump>` (default: off)
  Dumps additional information on the parallel execution with hpcom.

.. _omcflag-debug-hpcomMemoryOpt:

:ref:`hpcomMemoryOpt <omcflag-debug-hpcomMemoryOpt>` (default: off)
  Optimize the memory structure regarding the selected scheduler

.. _omcflag-debug-ignoreCycles:

:ref:`ignoreCycles <omcflag-debug-ignoreCycles>` (default: off)
  Ignores cycles between constant/parameter components.

.. _omcflag-debug-implOde:

:ref:`implOde <omcflag-debug-implOde>` (default: off)
  activates implicit codegen

.. _omcflag-debug-infoXmlOperations:

:ref:`infoXmlOperations <omcflag-debug-infoXmlOperations>` (default: off)
  Enables output of the operations in the _info.xml file when translating models.

.. _omcflag-debug-initialization:

:ref:`initialization <omcflag-debug-initialization>` (default: off)
  Shows additional information from the initialization process.

.. _omcflag-debug-inlineFunctions:

:ref:`inlineFunctions <omcflag-debug-inlineFunctions>` (default: on)
  Controls if function inlining should be performed.

.. _omcflag-debug-inlineSolver:

:ref:`inlineSolver <omcflag-debug-inlineSolver>` (default: off)
  Generates code for inline solver.

.. _omcflag-debug-instance:

:ref:`instance <omcflag-debug-instance>` (default: off)
  Prints extra failtrace from InstanceHierarchy.

.. _omcflag-debug-interactive:

:ref:`interactive <omcflag-debug-interactive>` (default: off)
  Starts omc as a server listening on the socket interface.

.. _omcflag-debug-interactiveCorba:

:ref:`interactiveCorba <omcflag-debug-interactiveCorba>` (default: off)
  Starts omc as a server listening on the Corba interface.

.. _omcflag-debug-interactivedump:

:ref:`interactivedump <omcflag-debug-interactivedump>` (default: off)
  Prints out debug information for the interactive server.

.. _omcflag-debug-iterationVars:

:ref:`iterationVars <omcflag-debug-iterationVars>` (default: off)
  Shows a list of all iteration variables.

.. _omcflag-debug-listAppendWrongOrder:

:ref:`listAppendWrongOrder <omcflag-debug-listAppendWrongOrder>` (default: on)
  Print notifications about bad usage of listAppend.

.. _omcflag-debug-lookup:

:ref:`lookup <omcflag-debug-lookup>` (default: off)
  Print extra failtrace from lookup.

.. _omcflag-debug-mergeAlgSections:

:ref:`mergeAlgSections <omcflag-debug-mergeAlgSections>` (default: off)
  Disables coloring algorithm while sparsity detection.

.. _omcflag-debug-mergeComponents:

:ref:`mergeComponents <omcflag-debug-mergeComponents>` (default: off)
  Enables automatic merging of components into arrays.

.. _omcflag-debug-metaModelicaRecordAllocWords:

:ref:`metaModelicaRecordAllocWords <omcflag-debug-metaModelicaRecordAllocWords>` (default: off)
  Instrument the source code to record memory allocations (requires run-time and generated files compiled with -DOMC_RECORD_ALLOC_WORDS).

.. _omcflag-debug-multirate:

:ref:`multirate <omcflag-debug-multirate>` (default: off)
  The solver can switch partitions in the system.

.. _omcflag-debug-newInst:

:ref:`newInst <omcflag-debug-newInst>` (default: on)
  Enables new instantiation phase.

.. _omcflag-debug-nfAPI:

:ref:`nfAPI <omcflag-debug-nfAPI>` (default: on)
  Enables experimental new instantiation use in the OMC API.

.. _omcflag-debug-nfAPIDynamicSelect:

:ref:`nfAPIDynamicSelect <omcflag-debug-nfAPIDynamicSelect>` (default: off)
  Show DynamicSelect(static, dynamic) in annotations. Default to false and will select the first (static) expression

.. _omcflag-debug-nfAPINoise:

:ref:`nfAPINoise <omcflag-debug-nfAPINoise>` (default: off)
  Enables error display for the experimental new instantiation use in the OMC API.

.. _omcflag-debug-nfEvalConstArgFuncs:

:ref:`nfEvalConstArgFuncs <omcflag-debug-nfEvalConstArgFuncs>` (default: on)
  Evaluate all functions with constant arguments in the new frontend.

.. _omcflag-debug-nfExpandFuncArgs:

:ref:`nfExpandFuncArgs <omcflag-debug-nfExpandFuncArgs>` (default: off)
  Expand all function arguments in the new frontend.

.. _omcflag-debug-nfExpandOperations:

:ref:`nfExpandOperations <omcflag-debug-nfExpandOperations>` (default: on)
  Expand all unary/binary operations to scalar expressions in the new frontend.

.. _omcflag-debug-nfScalarize:

:ref:`nfScalarize <omcflag-debug-nfScalarize>` (default: on)
  Run scalarization in NF, default true.

.. _omcflag-debug-oldFrontEndUnitCheck:

:ref:`oldFrontEndUnitCheck <omcflag-debug-oldFrontEndUnitCheck>` (default: off)
  Checks the consistency of units in equation (for the old front-end).

.. _omcflag-debug-optdaedump:

:ref:`optdaedump <omcflag-debug-optdaedump>` (default: off)
  Dumps information from the optimization modules.

.. _omcflag-debug-parallelCodegen:

:ref:`parallelCodegen <omcflag-debug-parallelCodegen>` (default: on)
  Enables code generation in parallel (disable this if compiling a model causes you to run out of RAM).

.. _omcflag-debug-paramdlowdump:

:ref:`paramdlowdump <omcflag-debug-paramdlowdump>` (default: off)
  Enables dumping of the parameters in the order they are calculated.

.. _omcflag-debug-partitionInitialization:

:ref:`partitionInitialization <omcflag-debug-partitionInitialization>` (default: on)
  This flag controls if partitioning is applied to the initialization system.

.. _omcflag-debug-patternmAllInfo:

:ref:`patternmAllInfo <omcflag-debug-patternmAllInfo>` (default: off)
  Adds notifications of all pattern-matching optimizations that are performed.

.. _omcflag-debug-patternmDeadCodeElimination:

:ref:`patternmDeadCodeElimination <omcflag-debug-patternmDeadCodeElimination>` (default: on)
  Performs dead code elimination in match-expressions.

.. _omcflag-debug-patternmMoveLastExp:

:ref:`patternmMoveLastExp <omcflag-debug-patternmMoveLastExp>` (default: on)
  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);

.. _omcflag-debug-patternmSkipFilterUnusedBindings:

:ref:`patternmSkipFilterUnusedBindings <omcflag-debug-patternmSkipFilterUnusedBindings>` (default: off)
  

.. _omcflag-debug-printRecordTypes:

:ref:`printRecordTypes <omcflag-debug-printRecordTypes>` (default: off)
  Prints out record types as part of the flat code.

.. _omcflag-debug-printStructuralParameters:

:ref:`printStructuralParameters <omcflag-debug-printStructuralParameters>` (default: off)
  Prints the structural parameters identified by the front-end

.. _omcflag-debug-pthreads:

:ref:`pthreads <omcflag-debug-pthreads>` (default: off)
  Experimental: Unused parallelization.

.. _omcflag-debug-relidx:

:ref:`relidx <omcflag-debug-relidx>` (default: off)
  Prints out debug information about relations, that are used as zero crossings.

.. _omcflag-debug-relocatableFunctions:

:ref:`relocatableFunctions <omcflag-debug-relocatableFunctions>` (default: off)
  Generates relocatable code: all functions become function pointers and can be replaced at run-time.

.. _omcflag-debug-reportSerializedSize:

:ref:`reportSerializedSize <omcflag-debug-reportSerializedSize>` (default: off)
  Reports serialized sizes of various data structures used in the compiler.

.. _omcflag-debug-reshufflePost:

:ref:`reshufflePost <omcflag-debug-reshufflePost>` (default: off)
  Reshuffles the systems of equations.

.. _omcflag-debug-resolveLoopsDump:

:ref:`resolveLoopsDump <omcflag-debug-resolveLoopsDump>` (default: off)
  Debug Output for ResolveLoops Module.

.. _omcflag-debug-rml:

:ref:`rml <omcflag-debug-rml>` (default: off)
  Converts Modelica-style arrays to lists.

.. _omcflag-debug-runtimeStaticLinking:

:ref:`runtimeStaticLinking <omcflag-debug-runtimeStaticLinking>` (default: off)
  Use the static simulation runtime libraries (C++ simulation runtime).

.. _omcflag-debug-scodeDep:

:ref:`scodeDep <omcflag-debug-scodeDep>` (default: on)
  Does scode dependency analysis prior to instantiation. Defaults to true.

.. _omcflag-debug-semiLinear:

:ref:`semiLinear <omcflag-debug-semiLinear>` (default: off)
  Enables dumping of the optimization information when optimizing calls to semiLinear.

.. _omcflag-debug-shortOutput:

:ref:`shortOutput <omcflag-debug-shortOutput>` (default: off)
  Enables short output of the simulate() command. Useful for tools like OMNotebook.

.. _omcflag-debug-showDaeGeneration:

:ref:`showDaeGeneration <omcflag-debug-showDaeGeneration>` (default: off)
  Show the dae variable declarations as they happen.

.. _omcflag-debug-showEquationSource:

:ref:`showEquationSource <omcflag-debug-showEquationSource>` (default: off)
  Display the element source information in the dumped DAE for easier debugging.

.. _omcflag-debug-showExpandableInfo:

:ref:`showExpandableInfo <omcflag-debug-showExpandableInfo>` (default: off)
  Show information about expandable connector handling.

.. _omcflag-debug-showInstCacheInfo:

:ref:`showInstCacheInfo <omcflag-debug-showInstCacheInfo>` (default: off)
  Prints information about instantiation cache hits and additions. Defaults to false.

.. _omcflag-debug-showStartOrigin:

:ref:`showStartOrigin <omcflag-debug-showStartOrigin>` (default: off)
  Enables dumping of the DAE startOrigin attribute of the variables.

.. _omcflag-debug-showStatement:

:ref:`showStatement <omcflag-debug-showStatement>` (default: off)
  Shows the statement that is currently being evaluated when evaluating a script.

.. _omcflag-debug-skipInputOutputSyntacticSugar:

:ref:`skipInputOutputSyntacticSugar <omcflag-debug-skipInputOutputSyntacticSugar>` (default: off)
  Used when bootstrapping to preserve the input output parsing of the code output by the list command.

.. _omcflag-debug-stateselection:

:ref:`stateselection <omcflag-debug-stateselection>` (default: off)
  Enables dumping of selected states. Extends -d=backenddaeinfo.

.. _omcflag-debug-static:

:ref:`static <omcflag-debug-static>` (default: off)
  Enables extra debug output from the static elaboration.

.. _omcflag-debug-stripPrefix:

:ref:`stripPrefix <omcflag-debug-stripPrefix>` (default: on)
  Strips the environment prefix from path/crefs. Defaults to true.

.. _omcflag-debug-susanDebug:

:ref:`susanDebug <omcflag-debug-susanDebug>` (default: off)
  Makes Susan generate code using try/else to better debug which function broke the expected match semantics.

.. _omcflag-debug-symJacConstantSplit:

:ref:`symJacConstantSplit <omcflag-debug-symJacConstantSplit>` (default: off)
  Generates all symbolic Jacobians with splitted constant parts.

.. _omcflag-debug-symjacdump:

:ref:`symjacdump <omcflag-debug-symjacdump>` (default: off)
  Dumps information about symbolic Jacobians. Can be used only with postOptModules: generateSymbolicJacobian, generateSymbolicLinearization.

.. _omcflag-debug-symjacdumpeqn:

:ref:`symjacdumpeqn <omcflag-debug-symjacdumpeqn>` (default: off)
  Dump for debug purpose of symbolic Jacobians. (deactivated now).

.. _omcflag-debug-symjacdumpverbose:

:ref:`symjacdumpverbose <omcflag-debug-symjacdumpverbose>` (default: off)
  Dumps information in verbose mode about symbolic Jacobians. Can be used only with postOptModules: generateSymbolicJacobian, generateSymbolicLinearization.

.. _omcflag-debug-symjacwarnings:

:ref:`symjacwarnings <omcflag-debug-symjacwarnings>` (default: off)
  Prints warnings regarding symoblic jacbians.

.. _omcflag-debug-tail:

:ref:`tail <omcflag-debug-tail>` (default: off)
  Prints out a notification if tail recursion optimization has been applied.

.. _omcflag-debug-tearingdump:

:ref:`tearingdump <omcflag-debug-tearingdump>` (default: off)
  Dumps tearing information.

.. _omcflag-debug-tearingdumpV:

:ref:`tearingdumpV <omcflag-debug-tearingdumpV>` (default: off)
  Dumps verbose tearing information.

.. _omcflag-debug-totaltearingdump:

:ref:`totaltearingdump <omcflag-debug-totaltearingdump>` (default: off)
  Dumps total tearing information.

.. _omcflag-debug-totaltearingdumpV:

:ref:`totaltearingdumpV <omcflag-debug-totaltearingdumpV>` (default: off)
  Dumps verbose total tearing information.

.. _omcflag-debug-tplPerfTimes:

:ref:`tplPerfTimes <omcflag-debug-tplPerfTimes>` (default: off)
  Enables output of template performance data for rendering text to file.

.. _omcflag-debug-transformsbeforedump:

:ref:`transformsbeforedump <omcflag-debug-transformsbeforedump>` (default: off)
  Applies transformations required for code generation before dumping flat code.

.. _omcflag-debug-types:

:ref:`types <omcflag-debug-types>` (default: off)
  Prints extra failtrace from Types.

.. _omcflag-debug-uncertainties:

:ref:`uncertainties <omcflag-debug-uncertainties>` (default: off)
  Enables dumping of status when calling modelEquationsUC.

.. _omcflag-debug-updmod:

:ref:`updmod <omcflag-debug-updmod>` (default: off)
  Prints information about modification updates.

.. _omcflag-debug-useMPI:

:ref:`useMPI <omcflag-debug-useMPI>` (default: off)
  Add MPI init and finalize to main method (CPPruntime).

.. _omcflag-debug-vectorize:

:ref:`vectorize <omcflag-debug-vectorize>` (default: off)
  Activates vectorization in the backend.

.. _omcflag-debug-vectorizeBindings:

:ref:`vectorizeBindings <omcflag-debug-vectorizeBindings>` (default: off)
  Turns on vectorization of bindings when scalarization is turned off.

.. _omcflag-debug-visxml:

:ref:`visxml <omcflag-debug-visxml>` (default: off)
  Outputs a xml-file that contains information for visualization.

.. _omcflag-debug-warnMinMax:

:ref:`warnMinMax <omcflag-debug-warnMinMax>` (default: on)
  Makes a warning assert from min/max variable attributes instead of error.

.. _omcflag-debug-warnNoNominal:

:ref:`warnNoNominal <omcflag-debug-warnNoNominal>` (default: off)
  Prints the iteration variables in the initialization and simulation DAE, which do not have a nominal value.

.. _omcflag-debug-writeToBuffer:

:ref:`writeToBuffer <omcflag-debug-writeToBuffer>` (default: off)
  Enables writing simulation results to buffer.

.. _omcflag-debug-zmqDangerousAcceptConnectionsFromAnywhere:

:ref:`zmqDangerousAcceptConnectionsFromAnywhere <omcflag-debug-zmqDangerousAcceptConnectionsFromAnywhere>` (default: off)
  When opening a zmq connection, listen on all interfaces instead of only connections from 127.0.0.1.

.. _omcflag-optmodules-section:

Flags for Optimization Modules
------------------------------

Flags that determine which symbolic methods are used to produce the causalized equation system.

The :ref:`--preOptModules <omcflag-preOptModules>` flag sets the optimization modules which are used before the
matching and index reduction in the back end. These modules are specified as a comma-separated list.

The :ref:`--matchingAlgorithm <omcflag-matchingAlgorithm>` sets the method that is used for the matching algorithm, after the pre optimization modules.

The :ref:`--indexReductionMethod <omcflag-indexReductionMethod>` sets the method that is used for the index reduction, after the pre optimization modules.

The :ref:`--initOptModules <omcflag-initOptModules>` then sets the optimization modules which are used after the index reduction to optimize the system for initialization, specified as a comma-separated list.

The :ref:`--postOptModules <omcflag-postOptModules>` then sets the optimization modules which are used after the index reduction to optimize the system for simulation, specified as a comma-separated list.