Modelica3.2语义解析：统一的物理系统建模语言

需积分: 35 89 浏览量更新于2024-07-25 收藏 1.56MB PDF 举报

"Modelica是一种统一的面向对象的语言，用于物理系统的建模。它在Modelica3.2版本中有着稳定的语义，是学习Modelica的重要参考资料。这种语言被广泛应用于多领域建模，例如机器人、汽车、航空航天等领域的机械、电气、液压和控制子系统，以及过程导向的应用和电力生成与分配。Modelica模型通过微分、代数和离散方程进行数学描述，无需手动解决特定变量，工具能够自动决定。它的设计允许利用现有的专业算法，以高效处理包含超过十万方程的大规模模型，并且在硬件和软件工程中都有应用。" Modelica语义是Modelica编程的核心部分，它定义了如何理解和解析Modelica代码，确保不同工具间的互操作性。在Modelica3.2这个稳定版本中，语义规定了类的结构、继承、连接、函数和方程系统的解析规则。 1. **面向对象特性**：Modelica支持类、对象、继承和多态性等面向对象概念。类可以表示物理系统的组件，而继承则允许重用和扩展已存在的模型。多态性使得一个接口可以有不同的实现，增强了代码的灵活性和可复用性。 2. **连接概念**：Modelica中的连接机制允许模型组件之间进行交互。连接可以是物理连接，如流体系统的管道，也可以是逻辑连接，如控制系统的信号。这些连接在模型中以方程的形式表示。 3. **方程和不等式系统**：Modelica模型基于方程和不等式，这包括微分方程、代数方程和离散方程。工具会自动处理这些方程，确定哪些是初始条件，哪些是状态变量，以及如何求解它们。 4. **自动平衡**：Modelica的语义允许工具自动处理方程的平衡，这意味着不需要用户指定哪些变量需要求解。这对于大型复杂系统来说是一个巨大的优势，因为它减少了手动调整的工作量。 5. **库支持**：Modelica有一个丰富的库系统，包含了各种预定义的物理模型，如流体动力学、热力学、电子学等。这些库简化了模型构建过程，用户可以直接使用或修改库中的模型。 6. **多领域建模**：Modelica特别适合于跨学科的建模，可以轻松地组合不同领域的模型，如机械、电气、热力和控制系统。这使得Modelica成为复杂系统分析的理想选择。 7. **效率优化**：Modelica的设计考虑到了大规模模型的处理，允许工具利用专用算法来提高求解效率。这使得处理包含大量方程的模型成为可能。 8. **开放性和标准化**：Modelica是一种开源语言，由非营利的Modelica协会维护和更新。其标准公开透明，鼓励开发人员创建兼容的工具和库，促进了技术的持续发展和社区的繁荣。 Modelica语义为物理系统建模提供了一种强大而灵活的框架，它支持多领域建模，易于扩展，并具备自动求解和高效处理的能力。对于工程师和研究人员来说，掌握Modelica语义是理解和应用这种语言的关键，也是在各种工程领域进行建模和仿真工作的基础。

16 Modelica Language Specification 3.2

multiplicative and array

elementwise multiplicative

* / .* ./ 2*3 2/3

[1,2;3,4].*[2,3;5,6]

additive and array

elementwise additive

+ - +expr -expr

.+ .

a+b, a-b, +a, -a

[1,2;3,4].+[2,3;5,6]

relational < <= > >= == <> a<b, a<=b, a>b, ...

unary negation not expr not b1

logical and and b1 and b2

logical or or b1 or b2

array range expr : expr

expr : expr : expr

1:5

start:step:stop

conditional if expr then expr else expr if b then 3 else x

named argument ident = expr x = 2.26

The conditional operator may also include elseif-clauses. Equality = and assignment := are not expression

operators since they are allowed only in equations and in assignment statements respectively. All binary

expression operators are left associative, except exponentiation which is non-associative. The array range operator

is non-associative.

[The unary minus and plus in Modelica is slightly different than in Mathematica and in MATLAB

, since the

following expressions are illegal (whereas in Mathematica

and in MATLAB these are valid expressions):

2*-2 // = -4 in Mathematica/MATLAB; is illegal in Modelica

--2 // = 2 in Mathematica/MATLAB; is illegal in Modelica

++2 // = 2 in Mathematica/MATLAB; is illegal in Modelica

2--2 // = 4 in Mathematica/MATLAB; is illegal in Modelica

Non-associative exponentation and array range operator:

x^y^z // Not legal, use parenthesis to make it clear

a:b:c:d:e:f:g // Not legal, and scalar arguments gives no legal interpretation.

]

3.3 Evaluation Order

A tool is free to solve equations, reorder expressions and to not evaluate expressions if their values do not

influence the result (e.g. short-circuit evaluation of Boolean expressions). If-statements and if-expressions

guarantee that their clauses are only evaluated if the appropriate condition is true, but relational operators

generating state or time events will during continuous integration have the value from the most recent event.

If a numeric operation overflows the result is undefined. For literals it is recommended to automatically

convert the number to another type with greater precision.

3.3.1

Example: Guarding Expressions Against Incorrect Evaluation

[Example. If one wants to guard an expression against incorrect evaluation, it should be guarded by an if:

Boolean v[n];

Boolean b;

Intege

equation

r I;

x=v[I] and (I>=1 and I<=n); // Invalid

x=if (I>=1 and I<=n) then v[I] else false; // Correct

To guard square against square root of negative number use noEvent:

der(h)=if h>0 then –c*sqrt(h) else 0; // Incorrect

der(h)=if noEvent(h>0) then –c*sqrt(h) else 0; // Correct

MATLAB is a registered trademark of MathWorks Inc.

Mathematica is a registered trademark of Wolfram Research Inc.

18 Modelica Language Specification 3.2

logical_factor :

[ not ] relation

relation :

arithmetic_expression [ rel_op arithmetic_expression ]

rel_op :

"<" | "<=" | ">" | ">=" | "==" | "<>"

The following holds for relational operators:

 Relational operators <, <=, >, >=, ==, <>, are only defined for scalar operands of simple types. The result is

Boolean and is true or false if the relation is fulfilled or not, respectively.

 For operands of type String, str1 op str2 is for each relational operator, op, defined in terms of the C-

function

strcmp as strcmp(str1,str2) op 0.

 For operands of type Boolean,

false<true.

 For operands of enumeration types, the order is given by the order of declaration of the enumeration literals.

 In relations of the form v1 == v2 or v1 <> v2, v1 or v2 shall, unless used in a function, not be a subtype of

Real. [The reason for this rule is that relations with Real arguments are transformed to state events (see

Events, Section 8.5) and this transformation becomes unnecessarily complicated for the == and <>

relat

ional operators (e.g. two crossing functions instead of one crossing function needed, epsilon strategy

needed even at event instants). Furthermore, testing on equality of Real variables is questionable on

machines where the number length in registers is different to number length in main memory].

 Relations of the form “

v1 rel_op v2”, with v1 and v2 variables and rel_op a relational operator are

called elementary relations. If either

v1 or v2 or both variables are a subtype of Real, the relation is called a

Real elementary relation.

3.6 Miscellaneous Operators and Variables

Modelica also contains a few built-in operators which are not standard arithmetic, relational, or logical operators.

These are described below, including

time, which is a built-in variable, not an operator.

3.6.1

3.6.2

3.6.3

3.6.4

3.6.5

String Concatenation

Concatenation of strings (see the Modelica grammar) is denoted by the + operator in Modelica [e.g. "a" + "b"

becomes "ab"].

Array Constructor Operator

The array constructor operator { ... } is described in Section 10.4.

Array Concatenation Operator

The array concatenation operator [ ... ] is described in Section 10.4.2.

Array Range Operator

The array range constructor operator : is described in Section 10.4.3.

If-Expressions

An expression

if expression1 then expression2 else expression3

is one example of if-expression. First expression1, which must be boolean expression, is evaluated. If

expression1 is true expression2 is evaluated and is the value of the if-expression, else expression3 is

evaluated and is the value of the if-expression. The two expressions,

expression2 and expression3, must be

type compatible expressions (Section 6.6) giving the type of the if-expression. If-expressions with elseif are

defined by replacing elseif by else if. [Note: elseif has been added for symmetry with if-clauses.] For

short-circuit evaluation see Section 3.3.

[Ex

ample:

Integer i;

Integer sign_of_i1=if i<0 then -1 elseif i==0 then 0 else 1;

Integer sign_of_i2=if i<0 then -1 else if i==0 then 0 else 1;

]

3.6.6

3.6.7

Member Access Operator

It is possible to access members of a class instance using dot notation, i.e., the . operator.

[Example:

R1.R for accessing the resistance component R of resistor R1. Another use of dot notation: local

classes which are members of a class can of course also be accessed using dot notation on the name of the class,

not on instances of the class.]

Built-in Variable time

All declared variables are functions of the independent variable time. The variable time is a built-in variable

available in all classes, which is treated as an input variable. It is implicitly defined as:

input Real time (final quantity = "Time",

final unit = "s");

The value of the start attribute of time is set to the time instant at which the simulation is started.

[Example:

encapsulated model SineSource

import Modelica.Math.sin;

connector OutPort=output Real;

end SineSource;

utPort y=sin(time); // Uses the built-in variable time.

]

3.7 Built-in Intrinsic Operators with Function Syntax

Certain built-in operators of Modelica have the same syntax as a function call. However, they do not behave as a

mathematical function, because the result depends not only on the input arguments but also on the status of the

simulation.

There are also built-in functions that depend only on the input argument, but also may trigger events in

addition to returning a value. Intrinsic means that they are defined at the Modelica language level, not in the

Modelica library. The following built-in intrinsic operators/functions are available:

 Mathematical functions and conversion functions, see Section 3.7.1 below.

 D

erivative and special purpose operators with function syntax, see Section 3.7.2 below.

 Even

t-related operators with function syntax, see Section 3.7.3 below.

 A

rray operators/functions, see Section 10.1.1.

20 Modelica Language Specification 3.2

With exception of built-in operator String(..), all operators in this section can only be called with positional

arguments.

3.7.1 Numeric Functions and Conversion Functions

The following mathematical operators and functions, also including some conversion functions, are predefined in

Modelica, and are vectorizable according to Section 12.4.6, except for the

String function. The functions which

do not trigger events are described in the table below, whereas the event-triggering mathematical functions are

described in Section 3.7.1.1.

abs(v)

Is expanded into “noEvent(if v >= 0 then v else –v)”.

Argument v needs to be an Integer or Real expression.

sign(v)

Is expanded into “noEvent(if v>0 then 1 else if v<0

then –1 else 0

)”. Argument v needs to be an Integer or Real

expression.

sqrt(v)

Returns the square root of v if v>=0, otherwise an error occurs.

Argument v needs to be an Integer or Real expression.

Integer(e)

Returns the ordinal number of the enumeration value

E.enumvalue, where Integer(E.e1)=1, Integer(E.en)=

size(E)

, for an enumeration type E=enumeration(e1, ...

en)

. See also Section 4.8.5.2.

String(b, <options>)

String(i, <options>)

String(r,

significantDigits=d,

<options>)

String(r, format=s)

String(e, <options>)

Convert a scalar non-String expression to a String representation.

The first argument may be a Boolean b, an Integer i, a

Real r or an Enumeration e (Section 4.8.5.2). The optional

<options> are:

Integer minimumLength=0: minimum length of the

resulting string. If necessary, the blank character is used to fill up

unused space.

Boolean leftJustified = true: if true, the converted

result is left justified in the string; if false it is right justified in

the string.

For Real expressions the output shall be according to the

Modelica grammar. Integer

significantDigits=6: defines

the number of significant digits in the result string. [Examples:

12.3456", "0.0123456", "12345600", "1.23456E-10"].

The format string corresponding to options is:

 for Reals: (

if leftJustified then "-" else

"")+String(minimumLength)+"."+

String(signficantDigits)+"g"

 for Integers: (

if leftJustified then "-" else

"")+String(minimumLength)+"d"

Format string: According to ANSI-C the format string specifies

one conversion specifier (excluding the leading %), may not

contain length modifiers, and may not use "

*" for width and/or

precision. For all numeric values the format specifiers f, e, E,

g, G are allowed. For integral values it is also allowed to use

the d, i, o, x, X, u, and c-format specifiers (for non-integral

values a tool may round, truncate or use a different format if the

integer conversion characters are used).

The x,X-formats (hexa-decimal) and c (character) for Integers

剩余249页未读，继续阅读

bulankeshi

粉丝: 2
资源: 13

Modelica3.2语义解析：统一的物理系统建模语言

Modelica语言介绍.pdf

Modelica 3.2官方语义

Modelica 3.2语义基础培训教程

Modelica 3.2语义详解：方程与分类

1 Modelica 3.2_介绍

Modelica语言规范3.6 中文版

15 Modelica 3.2_高级用法 第一篇

5 Modelica 3.2_继承、变形和重声明

将架构分析和设计语言转换成Modelica的机制

论文研究-对编译器前端生成器Front的语法和语义扩展.pdf

最新资源

15 Modelica 3.2_高级用法第一篇