Modelica语言学习指南 v3.2

需积分: 9 106 浏览量更新于2024-07-09 收藏 1.84MB PDF 举报

"ModelicaSpec.pdf 是一份关于Modelica语言的学习文档，旨在帮助初学者理解和掌握Modelica这种统一的面向对象的物理系统建模语言。该文档详细定义了Modelica语言的版本3.2，由非营利组织Modelica协会制定。Modelica语言是免费提供的，适用于构建大型、复杂和异构的物理系统的模型，尤其适合多领域建模，如机械、电气、液压和控制子系统的机器人、汽车和航空航天应用，以及过程导向型应用和电力的生成与分配。在Modelica中，模型通过微分、代数和离散方程进行数学描述，无需手动解决特定变量，工具能够自动处理。Modelica设计考虑了高效性，允许利用现有的专业化算法来处理包含数十万方程的大模型，并已被广泛使用。" 本文将深入探讨Modelica语言的核心特性、设计理念和应用场景，以便读者更好地理解和应用Modelica。 1. **面向对象编程**：Modelica是一种面向对象的语言，这意味着它支持类、继承、封装和多态等面向对象概念。这使得模型可以组织成具有明确定义的接口和行为的可重用组件，便于复用和模块化设计。 2. **物理系统建模**：Modelica的主要目的是为物理系统建模提供一个统一的框架。它支持各种工程领域的模型，如机械、电气、热力学、流体动力学等，使得不同领域之间的交互和耦合变得容易。 3. **动态方程的自动求解**：Modelica中的模型是用微分、代数和离散方程表示的，工具会自动处理这些方程的求解，无需用户手动干预。这大大简化了建模过程，提高了效率。 4. **平衡方程的处理**：Modelica的自动求解机制能够处理大量的平衡方程，即使模型有超过十万的方程，也能有效地管理。这得益于其设计时考虑的高效算法。 5. **库支持**：Modelica有一个丰富的标准库，包含了各种预定义的物理组件和模型，如机械部件、电气元件、流体系统等。用户可以基于这些库快速构建复杂的模型。 6. **开放性和标准化**：Modelica语言是开放的，其规范由Modelica协会维护，确保了跨工具的兼容性和互操作性。这意味着模型可以在不同的Modelica工具之间自由交换。 7. **应用领域**：Modelica广泛应用于汽车行业的动力总成建模、航空航天的系统仿真、能源系统的优化设计、建筑能耗分析以及机器人技术等多个领域。 8. **集成开发环境（IDE）**：使用Modelica通常需要配合IDE，这些工具提供了图形化界面，支持模型的可视化编辑、编译、仿真和结果分析。 9. **教育和研究**：Modelica不仅用于工业界，也是教育和研究领域的重要工具，因为它能帮助学生和研究人员快速理解复杂系统的动态行为。通过深入了解和实践Modelica，工程师和科研人员可以更加高效地建模和仿真复杂系统，实现跨学科的设计和优化。同时，由于Modelica的开源特性和标准化，它也在不断发展壮大，吸引了全球范围内的开发者和用户社区共同参与其发展。

16 Modelica Language Specification 3.2 Revision 2

]

3.4 Arithmetic Operators

Modelica supports five binary arithmetic operators that operate on any numerical type:

Exponentiation

Multiplication

Division

Addition

Subtraction

Some of these operators can also be applied to a combination of a scalar type and an array type, see Section 10.6.

The syntax of these operators is defined by the following rules from the Modelica grammar:

arithmetic_expression :

[ add_op ] term { add_op term }

add_op :

"+" | "-"

term :

factor { mul_op factor }

mul_op :

"*" | "/"

factor :

primary [ "^" primary ]

3.5 Equality, Relational, and Logical Operators

Modelica supports the standard set of relational and logical operators, all of which produce the standard boolean

values

true or false.

greater than

greater than or equal

less than

less than or equal to

equality within expressions

Inequality

A single equals sign = is never used in relational expressions, only in equations (Chapter 8, Section 10.6.1) and in

function calls using named parameter passing (Section 12.4.1).

The following logical operators are defined:

not

negation, unary operator

and

logical and

logical or

The grammar rules define the syntax of the relational and logical operators.

logical_expression :

logical_term { or logical_term }

logical_term :

logical_factor { and logical_factor }

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 <>

relational 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 String Concatenation

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

becomes

"ab"].

3.6.2 Array Constructor Operator

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

3.6.3 Array Concatenation Operator

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

3.6.4 Array Range Operator

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

3.6.5 If-Expressions

An expression

18 Modelica Language Specification 3.2 Revision 2

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.

[Example:

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 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.]

3.6.7 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 models and blocks, 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;

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

end SineSource;

]

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.

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

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

• Array operators/functions, see Section 10.1.1.

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

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 expression

of enumeration

type that evaluates to 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).

20 Modelica Language Specification 3.2 Revision 2

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

does not lead to input that agrees with the Modelica-grammar.

3.7.1.1 Event Triggering Mathematical Functions

The built-in operators in this section trigger state events if used outside of a when-clause.[ If this is not desired,

the

noEvent function can be applied to them. E.g. noEvent(integer(v)) ]

div(x,y)

Returns the algebraic quotient x/y with any fractional part discarded (also known as

truncation toward zero). [

Note: this is defined for / in C99; in C89 the result for

negative numbers is implementation-defined, so the standard function div() must

be used.]. Result and arguments shall have type Real or Integer.

If either of the

arguments is Real the result is Real otherwise Integer.

mod(x,y)

Returns the integer modulus of x/y, i.e. mod(x,y)=x-floor(x/y)*y. Result and

arguments shall have type Real or Integer. If either of the arguments is Real the

result is Real otherwise Integer. [Note, outside of a when-

clause state events are

triggered when the return value changes discontinuously. Examples

mod(3,1.4)=0.2, mod(-3,1.4)=1.2, mod(3,-1.4)=-1.2]

rem(x,y)

Returns the integer remainder of

x/y

, such that div(x,y)*y + rem(x, y) =

. Result and arguments shall have type Real or Integer. If either of the arguments is

Real the result is Real otherwise Integer. [Note, outside of a when-

clause state events

are triggered when the return value changes

discontinuously. Examples

rem(3,1.4)=0.2, rem(-3,1.4)=-0.2]

ceil(x)

Returns the smallest integer not less than x. Result and argument shall have type

Real. [Note, outside of a when-

clause state events are triggered when the return

value changes discontinuously.]

floor(x)

Returns the largest integer not greater than x. Result and argument shall have type

Real. [Note, outside of a when-

clause state events are triggered when the return

value changes discontinuously.].

integer(x)

Returns the largest integer not greater than x. The argument shall have type Real.

The result has type Integer.

[Note, outside of a when-clause state events are triggered when the return value

changes discontinuously.].

3.7.1.2 Built-in Mathematical Functions and External Built-in Functions

The following built-in mathematical functions are available in Modelica and can be called directly without any

package prefix added to the function name. They are also available as external built-in functions in the

Modelica.Math library.

sin(x)

sine

cos(x)

cosine

tan(x)

tangent (x shall not be: ..., -π/2, π/2, 3π/2, ...)

asin(x)

inverse sine (-1 ≤ x ≤ 1)

acos(x)

inverse cosine (-1 ≤ x ≤ 1)

atan(x)

inverse tangent

atan2(y, x)

the atan2(y, x) function calculates the principal

剩余252页未读，继续阅读

yuanbenfeng

粉丝: 1
资源: 4

Modelica语言学习指南 v3.2

Kotlin开发的播放器（默认支持MediaPlayer播放器，可扩展VLC播放器、IJK播放器、EXO播放器、阿里云播放器）

【创新无忧】基于斑马优化算法ZOA优化极限学习机ELM实现乳腺肿瘤诊断附matlab代码.rar

全套S7-1200一拖三恒压供水程序样例+PID样例+触摸屏样例 1、此程序采用S7-1200PLC和KTP1000PN触摸屏人机执行PID控制变频器实现恒压供水. 包括plc程序，触摸屏程序

【未发表】基于白鲨优化算法WSO优化支持向量机SVM实现塑料热压成型预测附matlab代码.rar

电子商务师之职业道德试题.doc

android kotlin实现totp动态身份验证器

u-boot-ar9331.bin

车辆管理-JAVA-基于springboot车辆管理系统设计与实现（毕业论文+PPT）

数据结构-排序篇.html

第六章 基于定子电压定向矢量控制的双馈电机控制系统设计

最新资源

第六章基于定子电压定向矢量控制的双馈电机控制系统设计